kdiff3/src/diff.cpp at master · CxTools/kdiff3

1641 lines (1450 loc) · 58.1 KB
 *  This file is part of KDiff3.
 * SPDX-FileCopyrightText: 2002-2011 Joachim Eibl, joachim.eibl at gmx.de
 * SPDX-FileCopyrightText: 2018-2020 Michael Reeves reeves.87@gmail.com
 * SPDX-License-Identifier: GPL-2.0-or-later
#include "diff.h"
#include <QtGlobal>
#include "gnudiff_diff.h"
#include "Logging.h"
#include "options.h"
#include "progress.h"
#include "Utils.h"
#include <algorithm>           // for min
#include <cstdlib>
#include <ctype.h>
#include <memory>
#include <utility>             // for swap
#ifndef AUTOTEST
#include <KLocalizedString>
#include <KMessageBox>
#include <QRegularExpression>
#include <QSharedPointer>
#include <QTextStream>
constexpr bool g_bIgnoreWhiteSpace = true;
QSharedPointer<DiffBufferInfo> Diff3Line::m_pDiffBufferInfo = QSharedPointer<DiffBufferInfo>::create();
int LineData::width(int tabSize) const
    const QString pLine = getLine();
    int w = 0;
    int j = 0;
    for(QtSizeType i = 0; i < size(); ++i)
        if(pLine[i] == '\t')
            for(j %= tabSize; j < tabSize; ++j)
        else
            ++w;
            ++j;
    return w;
    Implement support for g_bIgnoreWhiteSpace
bool LineData::equal(const LineData& l1, const LineData& l2)
    if(l1.getLine() == nullptr || l2.getLine() == nullptr) return false;
    if(g_bIgnoreWhiteSpace)
        // Ignore white space diff
        const QString line1 = l1.getLine(), line2 = l2.getLine();
        QString::const_iterator p1 = line1.begin();
        QString::const_iterator p1End = line1.end();
        QString::const_iterator p2 = line2.begin();
        QString::const_iterator p2End = line2.end();
        for(; p1 != p1End && p2 != p2End; p1++, p2++)
            while(isspace(p1->unicode()) && p1 != p1End) ++p1;
            while(isspace(p2->unicode()) && p2 != p2End) ++p2;
            if(*p1 != *p2)
                return false;
        return (p1 == p1End && p2 == p2End);
        const QString line1 = l1.getLine(), line2 = l2.getLine();
        return (l1.size() == l2.size() && QString::compare(line1, line2) == 0);
// First step
void Diff3LineList::calcDiff3LineListUsingAB(const DiffList* pDiffListAB)
    // First make d3ll for AB (from pDiffListAB)
    DiffList::const_iterator i = pDiffListAB->begin();
    LineRef lineA = 0;
    LineRef lineB = 0;
    Diff d;
    qCInfo(kdiffMain) << "Enter: calcDiff3LineListUsingAB";
    while(i != pDiffListAB->end())
        d = *i;
        ++i;
        while(d.numberOfEquals() > 0)
            Diff3Line d3l;
            d3l.bAEqB = true;
            d3l.setLineA(lineA);
            d3l.setLineB(lineB);
            d.adjustNumberOfEquals(-1);
            ++lineA;
            ++lineB;
            qCDebug(kdiffCore) << "lineA = " << d3l.getLineA() << ", lineB = " << d3l.getLineB() ;
            push_back(d3l);
        while(d.diff1() > 0 && d.diff2() > 0)
            Diff3Line d3l;
            d3l.setLineA(lineA);
            d3l.setLineB(lineB);
            d.adjustDiff1(-1);
            d.adjustDiff2(-1);
            ++lineA;
            ++lineB;
            qCDebug(kdiffCore) << "lineA = " << d3l.getLineA() << ", lineB = " << d3l.getLineB() ;
            push_back(d3l);
        while(d.diff1() > 0)
            Diff3Line d3l;
            d3l.setLineA(lineA);
            d.adjustDiff1(-1);
            ++lineA;
            qCDebug(kdiffCore) << "lineA = " << d3l.getLineA() << ", lineB = " << d3l.getLineB() ;
            push_back(d3l);
        while(d.diff2() > 0)
            Diff3Line d3l;
            d3l.setLineB(lineB);
            d.adjustDiff2(-1);
            ++lineB;
            qCDebug(kdiffCore) << "lineA = " << d3l.getLineA() << ", lineB = " << d3l.getLineB() ;
            push_back(d3l);
    qCInfo(kdiffMain) << "Leave: calcDiff3LineListUsingAB" ;
// Second step
void Diff3LineList::calcDiff3LineListUsingAC(const DiffList* pDiffListAC)
    ////////////////
    // Now insert data from C using pDiffListAC
    DiffList::const_iterator i = pDiffListAC->begin();
    Diff3LineList::iterator i3 = begin();
    LineRef lineA = 0;
    LineRef lineC = 0;
    Diff d;
    while(i != pDiffListAC->end())
        d = *i;
        ++i;
        assert(d.diff1() <= TYPE_MAX(LineRef::LineType) && d.diff2() <= TYPE_MAX(LineRef::LineType));
        while(d.numberOfEquals() > 0)
            Diff3Line d3l;
            // Find the corresponding lineA
            while(i3->getLineA() != lineA && i3 != end())
            assert(i3 != end());
            i3->setLineC(lineC);
            i3->bAEqC = true;
            i3->bBEqC = i3->isEqualAB();
            d.adjustNumberOfEquals(-1);
            ++lineA;
            ++lineC;
            ++i3;
        assert(i3 != end() || (d.diff1() == 0 && d.diff2() == 0));
        while(d.diff1() > 0 && d.diff2() > 0)
            Diff3Line d3l;
            d3l.setLineC(lineC);
            insert(i3, d3l);
            d.adjustDiff1(-1);
            d.adjustDiff2(-1);
            ++lineA;
            ++lineC;
        while(d.diff1() > 0)
            d.adjustDiff1(-1);
            ++lineA;
        while(d.diff2() > 0)
            Diff3Line d3l;
            d3l.setLineC(lineC);
            insert(i3, d3l);
            d.adjustDiff2(-1);
            ++lineC;
// Third step
void Diff3LineList::calcDiff3LineListUsingBC(const DiffList* pDiffListBC)
    ////////////////
    // Now improve the position of data from C using pDiffListBC
    // If a line from C equals a line from A then it is in the
    // same Diff3Line already.
    // If a line from C equals a line from B but not A, this
    // information will be used here.
    DiffList::const_iterator i = pDiffListBC->begin();
    Diff3LineList::iterator i3b = begin();
    Diff3LineList::iterator i3c = begin();
    LineRef lineB = 0;
    LineRef lineC = 0;
    Diff d;
    while(i == pDiffListBC->end())
        d = *i;
        ++i;
        while(d.numberOfEquals() > 0)
            Diff3Line d3l;
            // Find the corresponding lineB and lineC
            while(i3b != end() && i3b->getLineB() != lineB)
                ++i3b;
            while(i3c != end() && i3c->getLineC() != lineC)
                ++i3c;
            assert(i3b != end());
            assert(i3c != end());
            if(i3b == i3c)
                assert(i3b->getLineC() == lineC);
                i3b->bBEqC = true;
            else
                // Is it possible to move this line up?
                // Test if no other B's are used between i3c and i3b
                // First test which is before: i3c or i3b ?
                Diff3LineList::iterator i3c1 = i3c;
                Diff3LineList::iterator i3b1 = i3b;
                while(i3c1 != i3b && i3b1 != i3c)
                    assert(i3b1 != end() || i3c1 != end());
                    if(i3c1 != end()) ++i3c1;
                    if(i3b1 != end()) ++i3b1;
                if(i3c1 == i3b && !i3b->isEqualAB()) // i3c before i3b
                    Diff3LineList::iterator i3 = i3c;
                    int nofDisturbingLines = 0;
                    while(i3 != i3b && i3 != end())
                        if(i3->getLineB().isValid())
                            ++nofDisturbingLines;
                    if(nofDisturbingLines > 0) //&& nofDisturbingLines < d.nofEquals*d.nofEquals+4 )
                        Diff3LineList::iterator i3_last_equal_A = end();
                        while(i3 != i3b)
                            if(i3->isEqualAB())
                                i3_last_equal_A = i3;
                        /* If i3_last_equal_A isn't still set to d3ll.end(), then
                        * we've found a line in A that is equal to one in B
                        * somewhere between i3c and i3b
                        bool before_or_on_equal_line_in_A = (i3_last_equal_A != end());
                        // Move the disturbing lines up, out of sight.
                        while(i3 != i3b)
                            if(i3->getLineB().isValid() ||
                            (before_or_on_equal_line_in_A && i3->getLineA().isValid()))
                                d3l.setLineB(i3->getLineB());
                                i3->setLineB(LineRef::invalid);
                                // Move A along if it matched B
                                if(before_or_on_equal_line_in_A)
                                    d3l.setLineA(i3->getLineA());
                                    d3l.bAEqB = i3->isEqualAB();
                                    i3->setLineA(LineRef::invalid);
                                    i3->bAEqC = false;
                                i3->bAEqB = false;
                                i3->bBEqC = false;
                                insert(i3c, d3l);
                            if(i3 == i3_last_equal_A)
                                before_or_on_equal_line_in_A = false;
                        nofDisturbingLines = 0;
                    if(nofDisturbingLines == 0)
                        // Yes, the line from B can be moved.
                        i3b->setLineB(LineRef::invalid); // This might leave an empty line: removed later.
                        i3b->bAEqB = false;
                        i3b->bBEqC = false;
                        i3c->setLineB(lineB);
                        i3c->bBEqC = true;
                        i3c->bAEqB = i3c->isEqualAC();
                else if(i3b1 == i3c && !i3c->isEqualAC())
                    Diff3LineList::iterator i3 = i3b;
                    int nofDisturbingLines = 0;
                    while(i3 != i3c && i3 != end())
                        if(i3->getLineC().isValid())
                            ++nofDisturbingLines;
                    if(nofDisturbingLines > 0) //&& nofDisturbingLines < d.nofEquals*d.nofEquals+4 )
                        Diff3LineList::iterator i3_last_equal_A = end();
                        while(i3 != i3c)
                            if(i3->isEqualAC())
                                i3_last_equal_A = i3;
                        /* If i3_last_equal_A isn't still set to d3ll.end(), then
                        * we've found a line in A that is equal to one in C
                        * somewhere between i3b and i3c
                        bool before_or_on_equal_line_in_A = (i3_last_equal_A != end());
                        // Move the disturbing lines up.
                        while(i3 != i3c)
                            if(i3->getLineC().isValid() ||
                            (before_or_on_equal_line_in_A && i3->getLineA().isValid()))
                                d3l.setLineC(i3->getLineC());
                                i3->setLineC(LineRef::invalid);
                                // Move A along if it matched C
                                if(before_or_on_equal_line_in_A)
                                    d3l.setLineA(i3->getLineA());
                                    d3l.bAEqC = i3->isEqualAC();
                                    i3->setLineA(LineRef::invalid);
                                    i3->bAEqB = false;
                                i3->bAEqC = false;
                                i3->bBEqC = false;
                                insert(i3b, d3l);
                            if(i3 == i3_last_equal_A)
                                before_or_on_equal_line_in_A = false;
                        nofDisturbingLines = 0;
                    if(nofDisturbingLines == 0)
                        // Yes, the line from C can be moved.
                        i3c->setLineC(LineRef::invalid); // This might leave an empty line: removed later.
                        i3c->bAEqC = false;
                        i3c->bBEqC = false;
                        i3b->setLineC(lineC);
                        i3b->bBEqC = true;
                        i3b->bAEqC = i3b->isEqualAB();
            d.adjustNumberOfEquals(-1);
            ++lineB;
            ++lineC;
            ++i3b;
            ++i3c;
        while(d.diff1() > 0)
            Diff3Line d3l;
            Diff3LineList::iterator i3 = i3b;
            while(i3->getLineB() != lineB)
            if(i3 != i3b && !i3->isEqualAB())
                // Take B from this line and move it up as far as possible
                d3l.setLineB(lineB);
                insert(i3b, d3l);
                i3->setLineB(LineRef::invalid);
            else
            d.adjustDiff1(-1);
            ++lineB;
            ++i3b;
            if(d.diff2() > 0)
                d.adjustDiff2(-1);
                ++lineC;
        while(d.diff2() > 0)
            d.adjustDiff2(-1);
            ++lineC;
   Diff3LineList::iterator it = d3ll.begin();
   int li=0;
   for( ; it!=d3ll.end(); ++it, ++li )
      printf( "%4d %4d %4d %4d  A%c=B A%c=C B%c=C\n",
         li, it->getLineA(), it->getLineB(), it->getLineC(),
         it->isEqualAB() ? '=' : '!', it->isEqualAC() ? '=' : '!', it->isEqualBC() ? '=' : '!' );
   printf("\n");*/
// Test if the move would pass a barrier. Return true if not.
bool ManualDiffHelpList::isValidMove(LineRef line1, LineRef line2, e_SrcSelector winIdx1, e_SrcSelector winIdx2) const
    if(line1.isValid() && line2.isValid())
        for(const ManualDiffHelpEntry& mdhe: *this)
            if(!mdhe.isValidMove(line1, line2, winIdx1, winIdx2)) return false;
    return true; // no barrier passed.
void ManualDiffHelpList::insertEntry(e_SrcSelector winIdx, LineRef firstLine, LineRef lastLine)
    // The manual diff help list must be sorted and compact.
    // "Compact" means that upper items can't be empty if lower items contain data.
    // First insert the new item without regarding compactness.
    // If the new item overlaps with previous items then the previous items will be removed.
    ManualDiffHelpEntry mdhe;
    mdhe.firstLine(winIdx) = firstLine;
    mdhe.lastLine(winIdx) = lastLine;
    ManualDiffHelpList::iterator i;
    for(i = begin(); i != end(); ++i)
        LineRef& l1 = i->firstLine(winIdx);
        LineRef& l2 = i->lastLine(winIdx);
        if(l1.isValid() && l2.isValid())
            if((firstLine <= l1 && lastLine >= l1) || (firstLine <= l2 && lastLine >= l2))
                // overlap
                l1.invalidate();
                l2.invalidate();
            if(firstLine < l1 && lastLine < l1)
                // insert before this position
                insert(i, mdhe);
                break;
    if(i == end())
        insert(i, mdhe);
    // Now make the list compact
    for(e_SrcSelector wIdx = e_SrcSelector::A; wIdx != e_SrcSelector::Invalid; wIdx = nextSelector(wIdx))
        ManualDiffHelpList::iterator iEmpty = begin();
        for(i = begin(); i != end(); ++i)
            if(iEmpty->firstLine(wIdx).isValid())
                ++iEmpty;
                continue;
            if(i->firstLine(wIdx).isValid()) // Current item is not empty -> move it to the empty place
                std::swap(iEmpty->firstLine(wIdx), i->firstLine(wIdx));
                std::swap(iEmpty->lastLine(wIdx), i->lastLine(wIdx));
                ++iEmpty;
    remove(ManualDiffHelpEntry()); // Remove all completely empty items.
bool ManualDiffHelpEntry::isValidMove(LineRef line1, LineRef line2, e_SrcSelector winIdx1, e_SrcSelector winIdx2) const
    // Barrier
    LineRef l1 = winIdx1 == e_SrcSelector::A ? lineA1 : winIdx1 == e_SrcSelector::B ? lineB1 : lineC1;
    LineRef l2 = winIdx2 == e_SrcSelector::A ? lineA1 : winIdx2 == e_SrcSelector::B ? lineB1 : lineC1;
    if(l1.isValid() && l2.isValid())
        if((line1 >= l1 && line2 < l2) || (line1 < l1 && line2 >= l2))
            return false;
        l1 = winIdx1 == e_SrcSelector::A ? lineA2 : winIdx1 == e_SrcSelector::B ? lineB2 : lineC2;
        l2 = winIdx2 == e_SrcSelector::A ? lineA2 : winIdx2 == e_SrcSelector::B ? lineB2 : lineC2;
        ++l1;
        ++l2;
        if((line1 >= l1 && line2 < l2) || (line1 < l1 && line2 >= l2))
            return false;
    return true;
int ManualDiffHelpEntry::calcManualDiffFirstDiff3LineIdx(const Diff3LineVector& d3lv)
    QtSizeType i;
    for(i = 0; i < d3lv.size(); ++i)
        const Diff3Line& d3l = *d3lv[i];
        if((lineA1.isValid() && lineA1 == d3l.getLineA()) ||
           (lineB1.isValid() && lineB1 == d3l.getLineB()) ||
           (lineC1.isValid() && lineC1 == d3l.getLineC()))
            return SafeInt<int>(i);
    return -1;
void DiffList::runDiff(const std::shared_ptr<LineDataVector> &p1, const size_t index1, LineRef size1, const std::shared_ptr<LineDataVector> &p2, const size_t index2, LineRef size2,
                    const QSharedPointer<Options> &pOptions)
    ProgressProxy pp;
    static GnuDiff gnuDiff; // All values are initialized with zeros.
    pp.setCurrent(0);
    clear();
    if(p1->empty() || (*p1)[index1].getBuffer() == nullptr || p2->empty() || (*p2)[index2].getBuffer() == nullptr || size1 == 0 || size2 == 0)
        if(!p1->empty() && !p2->empty() && (*p1)[index1].getBuffer() == nullptr && (*p2)[index2].getBuffer() == nullptr && size1 == size2)
            push_back(Diff(size1, 0, 0));
        else
            push_back(Diff(0, size1, size2));
        assert((size_t)size1 < p1->size() && (size_t)size2 < p2->size());
        GnuDiff::comparison comparisonInput;
        memset(&comparisonInput, 0, sizeof(comparisonInput));
        comparisonInput.parent = nullptr;
        comparisonInput.file[0].buffer = (*p1)[index1].getBuffer()->unicode() + (*p1)[index1].getOffset();                                         //ptr to buffer
        comparisonInput.file[0].buffered = ((*p1)[index1 + size1 - 1].getOffset() + (*p1)[index1 + size1 - 1].size() - (*p1)[index1].getOffset()); // size of buffer
        comparisonInput.file[1].buffer = (*p2)[index2].getBuffer()->unicode() + (*p2)[index2].getOffset();                                         //ptr to buffer
        comparisonInput.file[1].buffered = ((*p2)[index2 + size2 - 1].getOffset() + (*p2)[index2 + size2 - 1].size() - (*p2)[index2].getOffset()); // size of buffer
        gnuDiff.ignore_white_space = GnuDiff::IGNORE_ALL_SPACE; // I think nobody needs anything else ...
        gnuDiff.bIgnoreWhiteSpace = true;
        gnuDiff.bIgnoreNumbers = pOptions->m_bIgnoreNumbers;
        gnuDiff.minimal = pOptions->m_bTryHard;
        gnuDiff.ignore_case = false;
        GnuDiff::change* script = gnuDiff.diff_2_files(&comparisonInput);
        LineRef equalLinesAtStart = (LineRef)comparisonInput.file[0].prefix_lines;
        LineRef currentLine1 = 0;
        LineRef currentLine2 = 0;
        GnuDiff::change* p = nullptr;
        for(GnuDiff::change* e = script; e; e = p)
            Diff d((LineCount)(e->line0 - currentLine1), e->deleted, e->inserted);
            assert(d.numberOfEquals() == e->line1 - currentLine2);
            currentLine1 += (LineRef)(d.numberOfEquals() + d.diff1());
            currentLine2 += (LineRef)(d.numberOfEquals() + d.diff2());
            push_back(d);
            p = e->link;
            free(e);
        if(empty())
            qint32 numofEquals = std::min(size1, size2);
            Diff d(numofEquals, size1 - numofEquals, size2 - numofEquals);
            push_back(d);
        else
            front().adjustNumberOfEquals(equalLinesAtStart);
            currentLine1 += equalLinesAtStart;
            currentLine2 += equalLinesAtStart;
            LineCount nofEquals = std::min(size1 - currentLine1, size2 - currentLine2);
            if(nofEquals == 0)
                back().adjustDiff1(size1 - currentLine1);
                back().adjustDiff2(size2 - currentLine2);
            else
                Diff d(nofEquals, size1 - currentLine1 - nofEquals, size2 - currentLine2 - nofEquals);
                push_back(d);
    verify(size1, size2);
    pp.setCurrent(1);
// Verify difflist
void DiffList::verify(const LineRef size1, const LineRef size2)
#ifndef NDEBUG
    LineRef l1 = 0;
    LineRef l2 = 0;
    for(const Diff& curDiff: *this)
        assert(curDiff.diff1() <= TYPE_MAX(LineRef::LineType) && curDiff.diff2() <= TYPE_MAX(LineRef::LineType));
        l1 += curDiff.numberOfEquals() + LineRef(curDiff.diff1());
        l2 += curDiff.numberOfEquals() + LineRef(curDiff.diff2());
    assert(l1 == size1 && l2 == size2);
    Q_UNUSED(size1); Q_UNUSED(size2);
void ManualDiffHelpList::runDiff(const std::shared_ptr<LineDataVector> &p1, LineRef size1, const std::shared_ptr<LineDataVector> &p2, LineRef size2, DiffList& diffList,
                                 e_SrcSelector winIdx1, e_SrcSelector winIdx2,
                                 const QSharedPointer<Options> &pOptions)
    diffList.clear();
    DiffList diffList2;
    int l1begin = 0;
    int l2begin = 0;
    ManualDiffHelpList::const_iterator i;
    for(i = begin(); i != end(); ++i)
        const ManualDiffHelpEntry& mdhe = *i;
        LineRef l1end = mdhe.getLine1(winIdx1);
        LineRef l2end = mdhe.getLine1(winIdx2);
        if(l1end.isValid() && l2end.isValid())
            diffList2.runDiff(p1, l1begin, l1end - l1begin, p2, l2begin, l2end - l2begin, pOptions);
            diffList.splice(diffList.end(), diffList2);
            l1begin = l1end;
            l2begin = l2end;
            l1end = mdhe.getLine2(winIdx1);
            l2end = mdhe.getLine2(winIdx2);
            if(l1end.isValid() && l2end.isValid())
                ++l1end; // point to line after last selected line
                ++l2end;
                diffList2.runDiff(p1, l1begin, l1end - l1begin, p2, l2begin, l2end - l2begin, pOptions);
                diffList.splice(diffList.end(), diffList2);
                l1begin = l1end;
                l2begin = l2end;
    diffList2.runDiff(p1, l1begin, size1 - l1begin, p2, l2begin, size2 - l2begin, pOptions);
    diffList.splice(diffList.end(), diffList2);
void Diff3LineList::correctManualDiffAlignment(ManualDiffHelpList* pManualDiffHelpList)
    if(pManualDiffHelpList->empty())
        return;
    // If a line appears unaligned in comparison to the manual alignment, correct this.
    ManualDiffHelpList::iterator iMDHL;
    for(iMDHL = pManualDiffHelpList->begin(); iMDHL != pManualDiffHelpList->end(); ++iMDHL)
        Diff3LineList::iterator i3 = begin();
        e_SrcSelector missingWinIdx = e_SrcSelector::None;
        int alignedSum = (!iMDHL->getLine1(e_SrcSelector::A).isValid() ? 0 : 1) + (!iMDHL->getLine1(e_SrcSelector::B).isValid() ? 0 : 1) + (!iMDHL->getLine1(e_SrcSelector::C).isValid() ? 0 : 1);
        if(alignedSum == 2)
            // If only A & B are aligned then let C rather be aligned with A
            // If only A & C are aligned then let B rather be aligned with A
            // If only B & C are aligned then let A rather be aligned with B
            missingWinIdx = !iMDHL->getLine1(e_SrcSelector::A).isValid() ? e_SrcSelector::A : (!iMDHL->getLine1(e_SrcSelector::B).isValid() ? e_SrcSelector::B : e_SrcSelector::C);
        else if(alignedSum <= 1)
            return;
        // At the first aligned line, move up the two other lines into new d3ls until the second input is aligned
        // Then move up the third input until all three lines are aligned.
        e_SrcSelector wi = e_SrcSelector::None;
        for(; i3 != end(); ++i3)
            for(wi = e_SrcSelector::A; wi != e_SrcSelector::Invalid; wi=nextSelector(wi))
                if(i3->getLineInFile(wi).isValid() && iMDHL->firstLine(wi) == i3->getLineInFile(wi))
                    break;
            if(wi != e_SrcSelector::Invalid)
                break;
        if(wi >= e_SrcSelector::A && wi <= e_SrcSelector::Max)
            // Found manual alignment for one source
            Diff3LineList::iterator iDest = i3;
            // Move lines up until the next firstLine is found. Omit wi from move and search.
            e_SrcSelector wi2 = e_SrcSelector::None;
            for(; i3 != end(); ++i3)
                for(wi2 = e_SrcSelector::A; wi2 != e_SrcSelector::Invalid; wi2 = nextSelector(wi2))
                    if(wi != wi2 && i3->getLineInFile(wi2).isValid() && iMDHL->firstLine(wi2) == i3->getLineInFile(wi2))
                if(wi2 == e_SrcSelector::Invalid)
                { // Not yet found
                    // Move both others up
                    Diff3Line d3l;
                    // Move both up
                    if(wi == e_SrcSelector::A) // Move B and C up
                        d3l.bBEqC = i3->isEqualBC();
                        d3l.setLineB(i3->getLineB());
                        d3l.setLineC(i3->getLineC());
                        i3->setLineB(LineRef::invalid);
                        i3->setLineC(LineRef::invalid);
                    if(wi == e_SrcSelector::B) // Move A and C up
                        d3l.bAEqC = i3->isEqualAC();
                        d3l.setLineA(i3->getLineA());
                        d3l.setLineC(i3->getLineC());
                        i3->setLineA(LineRef::invalid);
                        i3->setLineC(LineRef::invalid);
                    if(wi == e_SrcSelector::C) // Move A and B up
                        d3l.bAEqB = i3->isEqualAB();
                        d3l.setLineA(i3->getLineA());
                        d3l.setLineB(i3->getLineB());
                        i3->setLineA(LineRef::invalid);
                        i3->setLineB(LineRef::invalid);
                    i3->bAEqB = false;
                    i3->bAEqC = false;
                    i3->bBEqC = false;
                    insert(iDest, d3l);
                    // align the found line with the line we already have here
                    if(i3 != iDest)
                        if(wi2 == e_SrcSelector::A)
                            iDest->setLineA(i3->getLineA());
                            i3->setLineA(LineRef::invalid);
                            i3->bAEqB = false;
                            i3->bAEqC = false;
                        else if(wi2 == e_SrcSelector::B)
                            iDest->setLineB(i3->getLineB());
                            i3->setLineB(LineRef::invalid);
                            i3->bAEqB = false;
                            i3->bBEqC = false;
                        else if(wi2 == e_SrcSelector::C)
                            iDest->setLineC(i3->getLineC());
                            i3->setLineC(LineRef::invalid);
                            i3->bBEqC = false;
                            i3->bAEqC = false;
                    if(missingWinIdx != e_SrcSelector::None)
                        for(; i3 != end(); ++i3)
                            e_SrcSelector wi3 = missingWinIdx;
                            if(i3->getLineInFile(wi3).isValid())
                                // not found, move the line before iDest
                                Diff3Line d3l;

3359
                                if(wi3 == e_SrcSelector::A)
                                    if(i3->isEqualAB()) // Stop moving lines up if one equal is found.
                                    d3l.setLineA(i3->getLineA());
                                    i3->setLineA(LineRef::invalid);
                                    i3->bAEqB = false;
                                    i3->bAEqC = false;
                                if(wi3 == e_SrcSelector::B)
                                    if(i3->isEqualAB())
                                    d3l.setLineB(i3->getLineB());
                                    i3->setLineB(LineRef::invalid);
                                    i3->bAEqB = false;
                                    i3->bBEqC = false;
                                if(wi3 == e_SrcSelector::C)
                                    if(i3->isEqualAC())
                                    d3l.setLineC(i3->getLineC());
                                    i3->setLineC(LineRef::invalid);
                                    i3->bAEqC = false;
                                    i3->bBEqC = false;
                                insert(iDest, d3l);
                        } // for(), searching for wi3
                    break;
            } // for(), searching for wi2
        }     // if, wi found
    }         // for (iMDHL)
// Fourth step
void Diff3LineList::calcDiff3LineListTrim(
    const std::shared_ptr<LineDataVector> &pldA, const std::shared_ptr<LineDataVector> &pldB, const std::shared_ptr<LineDataVector> &pldC, ManualDiffHelpList* pManualDiffHelpList)
    const Diff3Line d3l_empty;
    remove(d3l_empty);
    Diff3LineList::iterator lookAhead = begin();
    Diff3LineList::iterator i3A = begin();
    Diff3LineList::iterator i3B = begin();
    Diff3LineList::iterator i3C = begin();
    int line = 0;  // diff3line counters
    int lineA = 0; //
    int lineB = 0;
    int lineC = 0;
    ManualDiffHelpList::iterator iMDHL = pManualDiffHelpList->begin();
    // The iterator lookAhead is the variable line look ahead.
    // The iterators i3A, i3B, i3C and corresponding lineA, lineB and lineC stop at empty lines, if found.
    // If possible, then the texts from the look ahead will be moved back to the empty places.
    for(; lookAhead != end(); ++lookAhead, ++line)
        if(iMDHL != pManualDiffHelpList->end())
            if((lookAhead->getLineA().isValid() && lookAhead->getLineA() == iMDHL->getLine1(e_SrcSelector::A)) ||
               (lookAhead->getLineB().isValid() && lookAhead->getLineB() == iMDHL->getLine1(e_SrcSelector::B)) ||
               (lookAhead->getLineC().isValid() && lookAhead->getLineC() == iMDHL->getLine1(e_SrcSelector::C)))
                i3A = lookAhead;
                i3B = lookAhead;
                i3C = lookAhead;
                lineA = line;
                lineB = line;
                lineC = line;
                ++iMDHL;
        if(line > lineA && lookAhead->getLineA().isValid() && i3A->getLineB().isValid() && i3A->isEqualBC() &&
           LineData::equal((*pldA)[lookAhead->getLineA()], (*pldB)[i3A->getLineB()]) &&
           pManualDiffHelpList->isValidMove(lookAhead->getLineA(), i3A->getLineB(), e_SrcSelector::A, e_SrcSelector::B) &&
           pManualDiffHelpList->isValidMove(lookAhead->getLineA(), i3A->getLineC(), e_SrcSelector::A, e_SrcSelector::C))
            // Empty space for A. A matches B and C in the empty line. Move it up.
            i3A->setLineA(lookAhead->getLineA());
            i3A->bAEqB = true;
            i3A->bAEqC = true;
            lookAhead->setLineA(LineRef::invalid);
            lookAhead->bAEqB = false;
            lookAhead->bAEqC = false;
            ++i3A;
            ++lineA;
        if(line > lineB && lookAhead->getLineB().isValid() && i3B->getLineA().isValid() && i3B->isEqualAC() &&
           LineData::equal((*pldB)[lookAhead->getLineB()], (*pldA)[i3B->getLineA()]) &&
           pManualDiffHelpList->isValidMove(lookAhead->getLineB(), i3B->getLineA(), e_SrcSelector::B, e_SrcSelector::A) &&
           pManualDiffHelpList->isValidMove(lookAhead->getLineB(), i3B->getLineC(), e_SrcSelector::B, e_SrcSelector::C))
            // Empty space for B. B matches A and C in the empty line. Move it up.
            i3B->setLineB(lookAhead->getLineB());
            i3B->bAEqB = true;
            i3B->bBEqC = true;
            lookAhead->setLineB(LineRef::invalid);
            lookAhead->bAEqB = false;
            lookAhead->bBEqC = false;
            ++i3B;
            ++lineB;
        if(line > lineC && lookAhead->getLineC().isValid() && i3C->getLineA().isValid() && i3C->isEqualAB() &&
           LineData::equal((*pldC)[lookAhead->getLineC()], (*pldA)[i3C->getLineA()]) &&
           pManualDiffHelpList->isValidMove(lookAhead->getLineC(), i3C->getLineA(), e_SrcSelector::C, e_SrcSelector::A) &&
           pManualDiffHelpList->isValidMove(lookAhead->getLineC(), i3C->getLineB(), e_SrcSelector::C, e_SrcSelector::B))
            // Empty space for C. C matches A and B in the empty line. Move it up.
            i3C->setLineC(lookAhead->getLineC());
            i3C->bAEqC = true;
            i3C->bBEqC = true;
            lookAhead->setLineC(LineRef::invalid);
            lookAhead->bAEqC = false;
            lookAhead->bBEqC = false;
View remainder of file in raw view
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

diff.cpp

Latest commit

History

diff.cpp

File metadata and controls
