src/TortoiseMerge/DiffData.cpp

   1 // TortoiseGitMerge - a Diff/Patch program
   2
   3 // Copyright (C) 2006-2015 - TortoiseSVN
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 #include "stdafx.h"
  20 #pragma warning(push)
  21 #include "diff.h"
  22 #pragma warning(pop)
  23 #include "TempFile.h"
  24 #include "registry.h"
  25 #include "resource.h"
  26 #include "DiffData.h"
  27 #include "UnicodeUtils.h"
  28 #include "svn_dso.h"
  29 #include "MovedBlocks.h"
  30
  31 #pragma warning(push)
  32 #pragma warning(disable: 4702) // unreachable code
  33 int CDiffData::abort_on_pool_failure (int /*retcode*/)
  34 {
  35         abort ();
  36         return -1;
  37 }
  38 #pragma warning(pop)
  39
  40 CDiffData::CDiffData(void)
  41         : m_bViewMovedBlocks(false)
  42         , m_bPatchRequired(false)
  43 {
  44         apr_initialize();
  45         svn_dso_initialize2();
  46
  47         m_bBlame = false;
  48
  49         m_sPatchOriginal = _T(": original");
  50         m_sPatchPatched = _T(": patched");
  51 }
  52
  53 CDiffData::~CDiffData(void)
  54 {
  55         apr_terminate();
  56 }
  57
  58 void CDiffData::SetMovedBlocks(bool bViewMovedBlocks/* = true*/)
  59 {
  60         m_bViewMovedBlocks = bViewMovedBlocks;
  61 }
  62
  63 int CDiffData::GetLineCount() const
  64 {
  65         int count = (int)m_arBaseFile.GetCount();
  66         if (count < m_arTheirFile.GetCount())
  67                 count = m_arTheirFile.GetCount();
  68         if (count < m_arYourFile.GetCount())
  69                 count = m_arYourFile.GetCount();
  70         return count;
  71 }
  72
  73 svn_diff_file_ignore_space_t CDiffData::GetIgnoreSpaceMode(DWORD dwIgnoreWS) const
  74 {
  75         switch (dwIgnoreWS)
  76         {
  77         case 0:
  78                 return svn_diff_file_ignore_space_none;
  79         case 1:
  80                 return svn_diff_file_ignore_space_all;
  81         case 2:
  82                 return svn_diff_file_ignore_space_change;
  83         default:
  84                 return svn_diff_file_ignore_space_none;
  85         }
  86 }
  87
  88 svn_diff_file_options_t * CDiffData::CreateDiffFileOptions(DWORD dwIgnoreWS, bool bIgnoreEOL, apr_pool_t * pool)
  89 {
  90         svn_diff_file_options_t * options = svn_diff_file_options_create(pool);
  91         options->ignore_eol_style = bIgnoreEOL;
  92         options->ignore_space = GetIgnoreSpaceMode(dwIgnoreWS);
  93         return options;
  94 }
  95
  96 bool CDiffData::HandleSvnError(svn_error_t * svnerr)
  97 {
  98         TRACE(_T("diff-error in CDiffData::Load()\n"));
  99         TRACE(_T("diff-error in CDiffData::Load()\n"));
 100         CStringA sMsg = CStringA(svnerr->message);
 101         while (svnerr->child)
 102         {
 103                 svnerr = svnerr->child;
 104                 sMsg += _T("\n");
 105                 sMsg += CStringA(svnerr->message);
 106         }
 107         CString readableMsg = CUnicodeUtils::GetUnicode(sMsg);
 108         m_sError.Format(IDS_ERR_DIFF_DIFF, (LPCTSTR)readableMsg);
 109         svn_error_clear(svnerr);
 110         return false;
 111 }
 112
 113 void CDiffData::TieMovedBlocks(int from, int to, apr_off_t length)
 114 {
 115         for(int i=0; i<length; i++, to++, from++)
 116         {
 117                 int fromIndex = m_YourBaseLeft.FindLineNumber(from);
 118                 int toIndex = m_YourBaseRight.FindLineNumber(to);
 119                 if (toIndex < 0)
 120                         return;
 121                 m_YourBaseLeft.SetMovedIndex(fromIndex, toIndex, true);
 122                 m_YourBaseRight.SetMovedIndex(toIndex, fromIndex, false);
 123
 124                 toIndex = m_YourBaseBoth.FindLineNumber(to);
 125                 if (toIndex < 0)
 126                         return;
 127                 while((toIndex < m_YourBaseBoth.GetCount())&&
 128                           ((m_YourBaseBoth.GetState(toIndex) != DIFFSTATE_ADDED)&&
 129                           (!m_YourBaseBoth.IsMoved(toIndex))||(m_YourBaseBoth.IsMovedFrom(toIndex))||
 130                           (m_YourBaseBoth.GetLineNumber(toIndex) != to)))
 131                 {
 132                         toIndex++;
 133                 }
 134
 135                 fromIndex = m_YourBaseBoth.FindLineNumber(from);
 136                 if (fromIndex < 0)
 137                         return;
 138                 while((fromIndex < m_YourBaseBoth.GetCount())&&
 139                           ((m_YourBaseBoth.GetState(fromIndex) != DIFFSTATE_REMOVED)&&
 140                           (!m_YourBaseBoth.IsMoved(fromIndex))||(!m_YourBaseBoth.IsMovedFrom(fromIndex))||
 141                           (m_YourBaseBoth.GetLineNumber(fromIndex) != from)))
 142                 {
 143                         fromIndex++;
 144                 }
 145                 if ((fromIndex < m_YourBaseBoth.GetCount())&&(toIndex < m_YourBaseBoth.GetCount()))
 146                 {
 147                         m_YourBaseBoth.SetMovedIndex(fromIndex, toIndex, true);
 148                         m_YourBaseBoth.SetMovedIndex(toIndex, fromIndex, false);
 149                 }
 150         }
 151 }
 152
 153 bool CDiffData::CompareWithIgnoreWS(CString s1, CString s2, DWORD dwIgnoreWS) const
 154 {
 155         if (dwIgnoreWS == 2)
 156         {
 157                 s1 = s1.TrimLeft(_T(" \t"));
 158                 s2 = s2.TrimLeft(_T(" \t"));
 159         }
 160         else
 161         {
 162                 s1 = s1.TrimRight(_T(" \t"));
 163                 s2 = s2.TrimRight(_T(" \t"));
 164         }
 165
 166         return s1 != s2;
 167 }
 168
 169 void CDiffData::StickAndSkip(svn_diff_t * &tempdiff, apr_off_t &original_length_sticked, apr_off_t &modified_length_sticked) const
 170 {
 171         if((m_bViewMovedBlocks)&&(tempdiff->type == svn_diff__type_diff_modified))
 172         {
 173                 svn_diff_t * nextdiff = tempdiff->next;
 174                 while((nextdiff)&&(nextdiff->type == svn_diff__type_diff_modified))
 175                 {
 176                         original_length_sticked += nextdiff->original_length;
 177                         modified_length_sticked += nextdiff->modified_length;
 178                         tempdiff = nextdiff;
 179                         nextdiff = tempdiff->next;
 180                 }
 181         }
 182 }
 183
 184 BOOL CDiffData::Load()
 185 {
 186         m_arBaseFile.RemoveAll();
 187         m_arYourFile.RemoveAll();
 188         m_arTheirFile.RemoveAll();
 189
 190         m_YourBaseBoth.Clear();
 191         m_YourBaseLeft.Clear();
 192         m_YourBaseRight.Clear();
 193
 194         m_TheirBaseBoth.Clear();
 195         m_TheirBaseLeft.Clear();
 196         m_TheirBaseRight.Clear();
 197
 198         m_Diff3.Clear();
 199
 200         CRegDWORD regIgnoreWS = CRegDWORD(_T("Software\\TortoiseGitMerge\\IgnoreWS"));
 201         CRegDWORD regIgnoreEOL = CRegDWORD(_T("Software\\TortoiseGitMerge\\IgnoreEOL"), TRUE);
 202         CRegDWORD regIgnoreCase = CRegDWORD(_T("Software\\TortoiseGitMerge\\CaseInsensitive"), FALSE);
 203         CRegDWORD regIgnoreComments = CRegDWORD(_T("Software\\TortoiseGitMerge\\IgnoreComments"), FALSE);
 204         DWORD dwIgnoreWS = regIgnoreWS;
 205         bool bIgnoreEOL = ((DWORD)regIgnoreEOL)!=0;
 206         BOOL bIgnoreCase = ((DWORD)regIgnoreCase)!=0;
 207         bool bIgnoreComments = ((DWORD)regIgnoreComments)!=0;
 208
 209         // The Subversion diff API only can ignore whitespaces and eol styles.
 210         // It also can only handle one-byte charsets.
 211         // To ignore case changes or to handle UTF-16 files, we have to
 212         // save the original file in UTF-8 and/or the letters changed to lowercase
 213         // so the Subversion diff can handle those.
 214         CString sConvertedBaseFilename = m_baseFile.GetFilename();
 215         CString sConvertedYourFilename = m_yourFile.GetFilename();
 216         CString sConvertedTheirFilename = m_theirFile.GetFilename();
 217
 218         m_baseFile.StoreFileAttributes();
 219         m_theirFile.StoreFileAttributes();
 220         m_yourFile.StoreFileAttributes();
 221         //m_mergedFile.StoreFileAttributes();
 222
 223         bool bBaseNeedConvert  = false;
 224         bool bTheirNeedConvert = false;
 225         bool bYourNeedConvert  = false;
 226         bool bBaseIsUtf8  = false;
 227         bool bTheirIsUtf8 = false;
 228         bool bYourIsUtf8  = false;
 229
 230         if (IsBaseFileInUse())
 231         {
 232                 if (!m_arBaseFile.Load(m_baseFile.GetFilename()))
 233                 {
 234                         m_sError = m_arBaseFile.GetErrorString();
 235                         return FALSE;
 236                 }
 237                 bBaseNeedConvert = bIgnoreCase || bIgnoreComments || (m_arBaseFile.NeedsConversion()) || !m_rx._Empty();
 238                 bBaseIsUtf8 = (m_arBaseFile.GetUnicodeType()!=CFileTextLines::ASCII) || bBaseNeedConvert;
 239         }
 240
 241         if (IsTheirFileInUse())
 242         {
 243                 // m_arBaseFile.GetCount() is passed as a hint for the number of lines in this file
 244                 // It's a fair guess that the files will be roughly the same size
 245                 if (!m_arTheirFile.Load(m_theirFile.GetFilename(), m_arBaseFile.GetCount()))
 246                 {
 247                         m_sError = m_arTheirFile.GetErrorString();
 248                         return FALSE;
 249                 }
 250                 bTheirNeedConvert = bIgnoreCase || bIgnoreComments || (m_arTheirFile.NeedsConversion()) || !m_rx._Empty();
 251                 bTheirIsUtf8 = (m_arTheirFile.GetUnicodeType()!=CFileTextLines::ASCII) || bTheirNeedConvert;
 252         }
 253
 254         if (IsYourFileInUse())
 255         {
 256                 // m_arBaseFile.GetCount() is passed as a hint for the number of lines in this file
 257                 // It's a fair guess that the files will be roughly the same size
 258                 if (!m_arYourFile.Load(m_yourFile.GetFilename(), m_arBaseFile.GetCount()))
 259                 {
 260                         m_sError = m_arYourFile.GetErrorString();
 261                         return FALSE;
 262                 }
 263                 bYourNeedConvert = bIgnoreCase || bIgnoreComments || (m_arYourFile.NeedsConversion()) || !m_rx._Empty();
 264                 bYourIsUtf8 = (m_arYourFile.GetUnicodeType()!=CFileTextLines::ASCII) || bYourNeedConvert;
 265         }
 266
 267         // in case at least one of the files got converted or is UTF8
 268         // we have to convert all non UTF8 (ASCII) files
 269         // otherwise one file might be in ANSI and the other in UTF8 and we'll end up
 270         // with lines marked as different throughout the files even though the lines
 271         // would show no change at all in the viewer.
 272
 273         // convert all files we need to
 274         bool bIsUtf8 = bBaseIsUtf8 || bTheirIsUtf8 || bYourIsUtf8; // any file end as UTF8
 275         bBaseNeedConvert |= (IsBaseFileInUse() && !bBaseIsUtf8 && bIsUtf8);
 276         if (bBaseNeedConvert)
 277         {
 278                 sConvertedBaseFilename = CTempFiles::Instance().GetTempFilePathString();
 279                 m_baseFile.SetConvertedFileName(sConvertedBaseFilename);
 280                 m_arBaseFile.Save(sConvertedBaseFilename, true, true, 0, bIgnoreCase, m_bBlame
 281                                                 , bIgnoreComments, m_CommentLineStart, m_CommentBlockStart, m_CommentBlockEnd
 282                                                 , m_rx, m_replacement);
 283         }
 284         bYourNeedConvert |= (IsYourFileInUse() && !bYourIsUtf8 && bIsUtf8);
 285         if (bYourNeedConvert)
 286         {
 287                 sConvertedYourFilename = CTempFiles::Instance().GetTempFilePathString();
 288                 m_yourFile.SetConvertedFileName(sConvertedYourFilename);
 289                 m_arYourFile.Save(sConvertedYourFilename, true, true, 0, bIgnoreCase, m_bBlame
 290                                                 , bIgnoreComments, m_CommentLineStart, m_CommentBlockStart, m_CommentBlockEnd
 291                                                 , m_rx, m_replacement);
 292         }
 293         bTheirNeedConvert |= (IsTheirFileInUse() && !bTheirIsUtf8 && bIsUtf8);
 294         if (bTheirNeedConvert)
 295         {
 296                 sConvertedTheirFilename = CTempFiles::Instance().GetTempFilePathString();
 297                 m_theirFile.SetConvertedFileName(sConvertedTheirFilename);
 298                 m_arTheirFile.Save(sConvertedTheirFilename, true, true, 0, bIgnoreCase, m_bBlame
 299                                                 , bIgnoreComments, m_CommentLineStart, m_CommentBlockStart, m_CommentBlockEnd
 300                                                 , m_rx, m_replacement);
 301         }
 302
 303         // Calculate the number of lines in the largest of the three files
 304         int lengthHint = GetLineCount();
 305
 306         try
 307         {
 308                 m_YourBaseBoth.Reserve(lengthHint);
 309                 m_YourBaseLeft.Reserve(lengthHint);
 310                 m_YourBaseRight.Reserve(lengthHint);
 311
 312                 m_TheirBaseBoth.Reserve(lengthHint);
 313                 m_TheirBaseLeft.Reserve(lengthHint);
 314                 m_TheirBaseRight.Reserve(lengthHint);
 315         }
 316         catch (CMemoryException* e)
 317         {
 318                 e->GetErrorMessage(m_sError.GetBuffer(255), 255);
 319                 m_sError.ReleaseBuffer();
 320                 e->Delete();
 321                 return FALSE;
 322         }
 323
 324         apr_pool_t * pool = NULL;
 325         apr_pool_create_ex (&pool, NULL, abort_on_pool_failure, NULL);
 326
 327         // Is this a two-way diff?
 328         if (IsBaseFileInUse() && IsYourFileInUse() && !IsTheirFileInUse())
 329         {
 330                 if (!DoTwoWayDiff(sConvertedBaseFilename, sConvertedYourFilename, dwIgnoreWS, bIgnoreEOL, pool))
 331                 {
 332                         apr_pool_destroy (pool);                    // free the allocated memory
 333                         return FALSE;
 334                 }
 335         }
 336
 337         if (IsBaseFileInUse() && IsTheirFileInUse() && !IsYourFileInUse())
 338         {
 339                 ASSERT(FALSE);
 340         }
 341
 342         // Is this a three-way diff?
 343         if (IsBaseFileInUse() && IsTheirFileInUse() && IsYourFileInUse())
 344         {
 345                 m_Diff3.Reserve(lengthHint);
 346
 347                 if (!DoThreeWayDiff(sConvertedBaseFilename, sConvertedYourFilename, sConvertedTheirFilename, dwIgnoreWS, bIgnoreEOL, !!bIgnoreCase, pool))
 348                 {
 349                         apr_pool_destroy (pool);                    // free the allocated memory
 350                         return FALSE;
 351                 }
 352         }
 353
 354         // free the allocated memory
 355         apr_pool_destroy (pool);
 356
 357         m_arBaseFile.RemoveAll();
 358         m_arYourFile.RemoveAll();
 359         m_arTheirFile.RemoveAll();
 360
 361         return TRUE;
 362 }
 363
 364 bool
 365 CDiffData::DoTwoWayDiff(const CString& sBaseFilename, const CString& sYourFilename, DWORD dwIgnoreWS, bool bIgnoreEOL, apr_pool_t * pool)
 366 {
 367         svn_diff_file_options_t * options = CreateDiffFileOptions(dwIgnoreWS, bIgnoreEOL, pool);
 368         // convert CString filenames (UTF-16 or ANSI) to UTF-8
 369         CStringA sBaseFilenameUtf8 = CUnicodeUtils::GetUTF8(sBaseFilename);
 370         CStringA sYourFilenameUtf8 = CUnicodeUtils::GetUTF8(sYourFilename);
 371
 372         svn_diff_t * diffYourBase = NULL;
 373         svn_error_t * svnerr = svn_diff_file_diff_2(&diffYourBase, sBaseFilenameUtf8, sYourFilenameUtf8, options, pool);
 374
 375         if (svnerr)
 376                 return HandleSvnError(svnerr);
 377
 378         tsvn_svn_diff_t_extension * movedBlocks = NULL;
 379         if(m_bViewMovedBlocks)
 380                 movedBlocks = MovedBlocksDetect(diffYourBase, dwIgnoreWS, pool); // Side effect is that diffs are now splitted
 381
 382         svn_diff_t * tempdiff = diffYourBase;
 383         LONG baseline = 0;
 384         LONG yourline = 0;
 385         while (tempdiff)
 386         {
 387                 svn_diff__type_e diffType = tempdiff->type;
 388                 // Side effect described above overcoming - sticking together
 389                 apr_off_t original_length_sticked = tempdiff->original_length;
 390                 apr_off_t modified_length_sticked = tempdiff->modified_length;
 391                 StickAndSkip(tempdiff, original_length_sticked, modified_length_sticked);
 392
 393                 for (int i=0; i<original_length_sticked; i++)
 394                 {
 395                         if (baseline >= m_arBaseFile.GetCount())
 396                         {
 397                                 m_sError.LoadString(IDS_ERR_DIFF_NEWLINES);
 398                                 return false;
 399                         }
 400                         const CString& sCurrentBaseLine = m_arBaseFile.GetAt(baseline);
 401                         EOL endingBase = m_arBaseFile.GetLineEnding(baseline);
 402                         if (diffType == svn_diff__type_common)
 403                         {
 404                                 if (yourline >= m_arYourFile.GetCount())
 405                                 {
 406                                         m_sError.LoadString(IDS_ERR_DIFF_NEWLINES);
 407                                         return false;
 408                                 }
 409                                 const CString& sCurrentYourLine = m_arYourFile.GetAt(yourline);
 410                                 EOL endingYours = m_arYourFile.GetLineEnding(yourline);
 411                                 if (sCurrentBaseLine != sCurrentYourLine)
 412                                 {
 413                                         bool changedWS = false;
 414                                         if (dwIgnoreWS == 2 || dwIgnoreWS == 3)
 415                                                 changedWS = CompareWithIgnoreWS(sCurrentBaseLine, sCurrentYourLine, dwIgnoreWS);
 416                                         if (changedWS || dwIgnoreWS == 0)
 417                                         {
 418                                                 // one-pane view: two lines, one 'removed' and one 'added'
 419                                                 m_YourBaseBoth.AddData(sCurrentBaseLine, DIFFSTATE_REMOVEDWHITESPACE, yourline, endingBase, HIDESTATE_SHOWN, -1);
 420                                                 m_YourBaseBoth.AddData(sCurrentYourLine, DIFFSTATE_ADDEDWHITESPACE, yourline, endingYours, HIDESTATE_SHOWN, -1);
 421                                         }
 422                                         else
 423                                         {
 424                                                 m_YourBaseBoth.AddData(sCurrentYourLine, DIFFSTATE_NORMAL, yourline, endingBase, HIDESTATE_HIDDEN, -1);
 425                                         }
 426                                 }
 427                                 else
 428                                 {
 429                                         m_YourBaseBoth.AddData(sCurrentYourLine, DIFFSTATE_NORMAL, yourline, endingBase, HIDESTATE_HIDDEN, -1);
 430                                 }
 431                                 yourline++;     //in both files
 432                         }
 433                         else
 434                         { // small trick - we need here a baseline, but we fix it back to yourline at the end of routine
 435                                 m_YourBaseBoth.AddData(sCurrentBaseLine, DIFFSTATE_REMOVED, -1, endingBase, HIDESTATE_SHOWN, -1);
 436                         }
 437                         baseline++;
 438                 }
 439                 if (diffType == svn_diff__type_diff_modified)
 440                 {
 441                         for (int i=0; i<modified_length_sticked; i++)
 442                         {
 443                                 if (m_arYourFile.GetCount() > yourline)
 444                                 {
 445                                         m_YourBaseBoth.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_ADDED, yourline, m_arYourFile.GetLineEnding(yourline), HIDESTATE_SHOWN, -1);
 446                                 }
 447                                 yourline++;
 448                         }
 449                 }
 450                 tempdiff = tempdiff->next;
 451         }
 452
 453         HideUnchangedSections(&m_YourBaseBoth, NULL, NULL);
 454
 455         tempdiff = diffYourBase;
 456         baseline = 0;
 457         yourline = 0;
 458         while (tempdiff)
 459         {
 460                 if (tempdiff->type == svn_diff__type_common)
 461                 {
 462                         for (int i=0; i<tempdiff->original_length; i++)
 463                         {
 464                                 const CString& sCurrentYourLine = m_arYourFile.GetAt(yourline);
 465                                 EOL endingYours = m_arYourFile.GetLineEnding(yourline);
 466                                 const CString& sCurrentBaseLine = m_arBaseFile.GetAt(baseline);
 467                                 EOL endingBase = m_arBaseFile.GetLineEnding(baseline);
 468                                 if (sCurrentBaseLine != sCurrentYourLine)
 469                                 {
 470                                         bool changedWS = false;
 471                                         if (dwIgnoreWS == 2 || dwIgnoreWS == 3)
 472                                                 changedWS = CompareWithIgnoreWS(sCurrentBaseLine, sCurrentYourLine, dwIgnoreWS);
 473                                         if (changedWS || dwIgnoreWS == 0)
 474                                         {
 475                                                 m_YourBaseLeft.AddData(sCurrentBaseLine, DIFFSTATE_WHITESPACE, baseline, endingBase, HIDESTATE_SHOWN, -1);
 476                                                 m_YourBaseRight.AddData(sCurrentYourLine, DIFFSTATE_WHITESPACE, yourline, endingYours, HIDESTATE_SHOWN, -1);
 477                                         }
 478                                         else
 479                                         {
 480                                                 m_YourBaseLeft.AddData(sCurrentBaseLine, DIFFSTATE_NORMAL, baseline, endingBase, HIDESTATE_HIDDEN, -1);
 481                                                 m_YourBaseRight.AddData(sCurrentYourLine, DIFFSTATE_NORMAL, yourline, endingYours, HIDESTATE_HIDDEN, -1);
 482                                         }
 483                                 }
 484                                 else
 485                                 {
 486                                         m_YourBaseLeft.AddData(sCurrentBaseLine, DIFFSTATE_NORMAL, baseline, endingBase, HIDESTATE_HIDDEN, -1);
 487                                         m_YourBaseRight.AddData(sCurrentYourLine, DIFFSTATE_NORMAL, yourline, endingYours, HIDESTATE_HIDDEN, -1);
 488                                 }
 489                                 baseline++;
 490                                 yourline++;
 491                         }
 492                 }
 493                 if (tempdiff->type == svn_diff__type_diff_modified)
 494                 {
 495                         // now we trying to stick together parts, that were splitted by MovedBlocks
 496                         apr_off_t original_length_sticked = tempdiff->original_length;
 497                         apr_off_t modified_length_sticked = tempdiff->modified_length;
 498                         StickAndSkip(tempdiff, original_length_sticked, modified_length_sticked);
 499
 500                         apr_off_t original_length = original_length_sticked;
 501                         for (int i=0; i<modified_length_sticked; i++)
 502                         {
 503                                 if (m_arYourFile.GetCount() > yourline)
 504                                 {
 505                                         EOL endingYours = m_arYourFile.GetLineEnding(yourline);
 506                                         m_YourBaseRight.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_ADDED, yourline, endingYours, HIDESTATE_SHOWN, -1);
 507                                         if (original_length-- <= 0)
 508                                         {
 509                                                 m_YourBaseLeft.AddEmpty();
 510                                         }
 511                                         else
 512                                         {
 513                                                 EOL endingBase = m_arBaseFile.GetLineEnding(baseline);
 514                                                 m_YourBaseLeft.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_REMOVED, baseline, endingBase, HIDESTATE_SHOWN, -1);
 515                                                 baseline++;
 516                                         }
 517                                         yourline++;
 518                                 }
 519                         }
 520                         apr_off_t modified_length = modified_length_sticked;
 521                         for (int i=0; i<original_length_sticked; i++)
 522                         {
 523                                 if ((modified_length-- <= 0)&&(m_arBaseFile.GetCount() > baseline))
 524                                 {
 525                                         EOL endingBase = m_arBaseFile.GetLineEnding(baseline);
 526                                         m_YourBaseLeft.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_REMOVED, baseline, endingBase, HIDESTATE_SHOWN, -1);
 527                                         m_YourBaseRight.AddEmpty();
 528                                         baseline++;
 529                                 }
 530                         }
 531                 }
 532                 tempdiff = tempdiff->next;
 533         }
 534         // add last (empty) lines if needed - diff don't report those
 535         if (m_arBaseFile.GetCount() > baseline)
 536         {
 537                 if (m_arYourFile.GetCount() > yourline)
 538                 {
 539                         // last line is missing in both files add them to end and mark as no diff
 540                         m_YourBaseLeft.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_NORMAL, baseline, m_arBaseFile.GetLineEnding(baseline), HIDESTATE_SHOWN, -1);
 541                         m_YourBaseRight.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_NORMAL, yourline, m_arYourFile.GetLineEnding(yourline), HIDESTATE_SHOWN, -1);
 542                         yourline++;
 543                         baseline++;
 544                 }
 545                 else
 546                 {
 547                         viewdata oViewData(m_arBaseFile.GetAt(baseline), DIFFSTATE_REMOVED, baseline, m_arBaseFile.GetLineEnding(baseline), HIDESTATE_SHOWN);
 548                         baseline++;
 549
 550                         // find first EMPTY line in last blok
 551                         int nPos = m_YourBaseLeft.GetCount();
 552                         while (--nPos>=0 && m_YourBaseLeft.GetState(nPos)==DIFFSTATE_EMPTY) ;
 553                         if (++nPos<m_YourBaseLeft.GetCount())
 554                         {
 555                                 m_YourBaseLeft.SetData(nPos, oViewData);
 556                         }
 557                         else
 558                         {
 559                                 m_YourBaseLeft.AddData(oViewData);
 560                                 m_YourBaseRight.AddEmpty();
 561                         }
 562                 }
 563         }
 564         else if (m_arYourFile.GetCount() > yourline)
 565         {
 566                 viewdata oViewData(m_arYourFile.GetAt(yourline), DIFFSTATE_ADDED, yourline, m_arYourFile.GetLineEnding(yourline), HIDESTATE_SHOWN);
 567                 yourline++;
 568
 569                 // try to move last line higher
 570                 int nPos = m_YourBaseRight.GetCount();
 571                 while (--nPos>=0 && m_YourBaseRight.GetState(nPos)==DIFFSTATE_EMPTY) ;
 572                 if (++nPos<m_YourBaseRight.GetCount())
 573                 {
 574                         m_YourBaseRight.SetData(nPos, oViewData);
 575                 }
 576                 else
 577                 {
 578                         m_YourBaseLeft.AddEmpty();
 579                         m_YourBaseRight.AddData(oViewData);
 580                 }
 581         }
 582
 583
 584         // Fixing results for conforming moved blocks
 585
 586         while(movedBlocks)
 587         {
 588                 tempdiff = movedBlocks->base;
 589                 if(movedBlocks->moved_to != -1)
 590                 {
 591                         // set states in a block original:length -> moved_to:length
 592                         TieMovedBlocks((int)tempdiff->original_start, movedBlocks->moved_to, tempdiff->original_length);
 593                 }
 594                 if(movedBlocks->moved_from != -1)
 595                 {
 596                         // set states in a block modified:length -> moved_from:length
 597                         TieMovedBlocks(movedBlocks->moved_from, (int)tempdiff->modified_start, tempdiff->modified_length);
 598                 }
 599                 movedBlocks = movedBlocks->next;
 600         }
 601
 602         // replace baseline with the yourline in m_YourBaseBoth
 603 /*      yourline = 0;
 604         for(int i=0; i<m_YourBaseBoth.GetCount(); i++)
 605         {
 606                 DiffStates state = m_YourBaseBoth.GetState(i);
 607                 if((state == DIFFSTATE_REMOVED)||(state == DIFFSTATE_MOVED_FROM))
 608                 {
 609                         m_YourBaseBoth.SetLineNumber(i, -1);
 610                 }
 611                 else
 612                 {
 613                         yourline++;
 614                 }
 615         }//*/
 616
 617         TRACE(_T("done with 2-way diff\n"));
 618
 619         HideUnchangedSections(&m_YourBaseLeft, &m_YourBaseRight, NULL);
 620
 621         return true;
 622 }
 623
 624 bool
 625 CDiffData::DoThreeWayDiff(const CString& sBaseFilename, const CString& sYourFilename, const CString& sTheirFilename, DWORD dwIgnoreWS, bool bIgnoreEOL, bool bIgnoreCase, apr_pool_t * pool)
 626 {
 627         // the following three arrays are used to check for conflicts even in case the
 628         // user has ignored spaces/eols.
 629         CStdDWORDArray              m_arDiff3LinesBase;
 630         CStdDWORDArray              m_arDiff3LinesYour;
 631         CStdDWORDArray              m_arDiff3LinesTheir;
 632 #define AddLines(baseline, yourline, theirline) m_arDiff3LinesBase.Add(baseline), m_arDiff3LinesYour.Add(yourline), m_arDiff3LinesTheir.Add(theirline)
 633         int lengthHint = GetLineCount();
 634
 635         m_arDiff3LinesBase.Reserve(lengthHint);
 636         m_arDiff3LinesYour.Reserve(lengthHint);
 637         m_arDiff3LinesTheir.Reserve(lengthHint);
 638
 639         CRegDWORD contextLines = CRegDWORD(_T("Software\\TortoiseGitMerge\\ContextLines"), 3);
 640         svn_diff_file_options_t * options = CreateDiffFileOptions(dwIgnoreWS, bIgnoreEOL, pool);
 641
 642         // convert CString filenames (UTF-16 or ANSI) to UTF-8
 643         CStringA sBaseFilenameUtf8  = CUnicodeUtils::GetUTF8(sBaseFilename);
 644         CStringA sYourFilenameUtf8  = CUnicodeUtils::GetUTF8(sYourFilename);
 645         CStringA sTheirFilenameUtf8 = CUnicodeUtils::GetUTF8(sTheirFilename);
 646
 647         svn_diff_t * diffTheirYourBase = NULL;
 648         svn_error_t * svnerr = svn_diff_file_diff3_2(&diffTheirYourBase, sBaseFilenameUtf8, sTheirFilenameUtf8, sYourFilenameUtf8, options, pool);
 649         if (svnerr)
 650                 return HandleSvnError(svnerr);
 651
 652         svn_diff_t * tempdiff = diffTheirYourBase;
 653         LONG baseline = 0;
 654         LONG yourline = 0;
 655         LONG theirline = 0;
 656         LONG resline = 0;
 657         // common viewdata
 658         const viewdata emptyConflictEmpty(_T(""), DIFFSTATE_CONFLICTEMPTY, DIFF_EMPTYLINENUMBER, EOL_NOENDING, HIDESTATE_SHOWN);
 659         const viewdata emptyIdenticalRemoved(_T(""), DIFFSTATE_IDENTICALREMOVED, DIFF_EMPTYLINENUMBER, EOL_NOENDING, HIDESTATE_SHOWN);
 660         while (tempdiff)
 661         {
 662                 if (tempdiff->type == svn_diff__type_common)
 663                 {
 664                         ASSERT((tempdiff->latest_length == tempdiff->modified_length) && (tempdiff->modified_length == tempdiff->original_length));
 665                         for (int i=0; i<tempdiff->original_length; i++)
 666                         {
 667                                 if ((m_arYourFile.GetCount() > yourline)&&(m_arTheirFile.GetCount() > theirline))
 668                                 {
 669                                         AddLines(baseline, yourline, theirline);
 670
 671                                         m_Diff3.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_NORMAL, resline, m_arYourFile.GetLineEnding(yourline), HIDESTATE_HIDDEN, -1);
 672                                         m_YourBaseBoth.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_NORMAL, yourline, m_arYourFile.GetLineEnding(yourline), HIDESTATE_HIDDEN, -1);
 673                                         m_TheirBaseBoth.AddData(m_arTheirFile.GetAt(theirline), DIFFSTATE_NORMAL, theirline, m_arTheirFile.GetLineEnding(theirline), HIDESTATE_HIDDEN, -1);
 674
 675                                         baseline++;
 676                                         yourline++;
 677                                         theirline++;
 678                                         resline++;
 679                                 }
 680                         }
 681                 }
 682                 else if (tempdiff->type == svn_diff__type_diff_common)
 683                 {
 684                         ASSERT(tempdiff->latest_length == tempdiff->modified_length);
 685                         //both theirs and yours have lines replaced
 686                         for (int i=0; i<tempdiff->original_length; i++)
 687                         {
 688                                 if (m_arBaseFile.GetCount() > baseline)
 689                                 {
 690                                         AddLines(baseline, yourline, theirline);
 691
 692                                         m_Diff3.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_IDENTICALREMOVED, DIFF_EMPTYLINENUMBER, m_arBaseFile.GetLineEnding(baseline), HIDESTATE_SHOWN, -1);
 693                                         m_YourBaseBoth.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_IDENTICALREMOVED, DIFF_EMPTYLINENUMBER, EOL_NOENDING, HIDESTATE_SHOWN, -1);
 694                                         m_TheirBaseBoth.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_IDENTICALREMOVED, DIFF_EMPTYLINENUMBER, EOL_NOENDING, HIDESTATE_SHOWN, -1);
 695
 696                                         baseline++;
 697                                 }
 698                         }
 699                         for (int i=0; i<tempdiff->modified_length; i++)
 700                         {
 701                                 if ((m_arYourFile.GetCount() > yourline)&&(m_arTheirFile.GetCount() > theirline))
 702                                 {
 703                                         AddLines(baseline, yourline, theirline);
 704
 705                                         m_Diff3.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_IDENTICALADDED, resline, m_arYourFile.GetLineEnding(yourline), HIDESTATE_SHOWN, -1);
 706                                         m_YourBaseBoth.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_IDENTICALADDED, yourline, m_arYourFile.GetLineEnding(yourline), HIDESTATE_SHOWN, -1);
 707                                         m_TheirBaseBoth.AddData(m_arTheirFile.GetAt(theirline), DIFFSTATE_IDENTICALADDED, resline, m_arTheirFile.GetLineEnding(theirline), HIDESTATE_SHOWN, -1);
 708
 709                                         yourline++;
 710                                         theirline++;
 711                                         resline++;
 712                                 }
 713                         }
 714                 }
 715                 else if (tempdiff->type == svn_diff__type_conflict)
 716                 {
 717                         apr_off_t length = max(tempdiff->original_length, tempdiff->modified_length);
 718                         length = max(tempdiff->latest_length, length);
 719                         apr_off_t original = tempdiff->original_length;
 720                         apr_off_t modified = tempdiff->modified_length;
 721                         apr_off_t latest = tempdiff->latest_length;
 722
 723                         apr_off_t originalresolved = 0;
 724                         apr_off_t modifiedresolved = 0;
 725                         apr_off_t latestresolved = 0;
 726
 727                         LONG base = baseline;
 728                         LONG your = yourline;
 729                         LONG their = theirline;
 730                         if (tempdiff->resolved_diff)
 731                         {
 732                                 originalresolved = tempdiff->resolved_diff->original_length;
 733                                 modifiedresolved = tempdiff->resolved_diff->modified_length;
 734                                 latestresolved = tempdiff->resolved_diff->latest_length;
 735                         }
 736                         for (int i=0; i<length; i++)
 737                         {
 738                                 EOL endingBase = m_arBaseFile.GetCount() > baseline ? m_arBaseFile.GetLineEnding(baseline) : EOL_AUTOLINE;
 739                                 if (original)
 740                                 {
 741                                         if (m_arBaseFile.GetCount() > baseline)
 742                                         {
 743                                                 AddLines(baseline, yourline, theirline);
 744
 745                                                 m_Diff3.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_IDENTICALREMOVED, DIFF_EMPTYLINENUMBER, endingBase , HIDESTATE_SHOWN, -1);
 746                                                 m_YourBaseBoth.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_IDENTICALREMOVED, DIFF_EMPTYLINENUMBER, endingBase , HIDESTATE_SHOWN, -1);
 747                                                 m_TheirBaseBoth.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_IDENTICALREMOVED, DIFF_EMPTYLINENUMBER, endingBase , HIDESTATE_SHOWN, -1);
 748                                         }
 749                                 }
 750                                 else if ((originalresolved)||((modifiedresolved)&&(latestresolved)))
 751                                 {
 752                                         AddLines(baseline, yourline, theirline);
 753
 754                                         m_Diff3.AddData(emptyIdenticalRemoved);
 755                                         if ((latestresolved)&&(modifiedresolved))
 756                                         {
 757                                                 m_YourBaseBoth.AddData(emptyIdenticalRemoved);
 758                                                 m_TheirBaseBoth.AddData(emptyIdenticalRemoved);
 759                                         }
 760                                 }
 761                                 if (original)
 762                                 {
 763                                         original--;
 764                                         baseline++;
 765                                 }
 766                                 if (originalresolved)
 767                                         originalresolved--;
 768
 769                                 if (modified)
 770                                 {
 771                                         modified--;
 772                                         theirline++;
 773                                 }
 774                                 if (modifiedresolved)
 775                                         modifiedresolved--;
 776                                 if (latest)
 777                                 {
 778                                         latest--;
 779                                         yourline++;
 780                                 }
 781                                 if (latestresolved)
 782                                         latestresolved--;
 783                         }
 784                         original = tempdiff->original_length;
 785                         modified = tempdiff->modified_length;
 786                         latest = tempdiff->latest_length;
 787                         baseline = base;
 788                         yourline = your;
 789                         theirline = their;
 790                         if (tempdiff->resolved_diff)
 791                         {
 792                                 originalresolved = tempdiff->resolved_diff->original_length;
 793                                 modifiedresolved = tempdiff->resolved_diff->modified_length;
 794                                 latestresolved = tempdiff->resolved_diff->latest_length;
 795                         }
 796                         for (int i=0; i<length; i++)
 797                         {
 798                                 if ((latest)||(modified))
 799                                 {
 800                                         AddLines(baseline, yourline, theirline);
 801
 802                                         m_Diff3.AddData(_T(""), DIFFSTATE_CONFLICTED, resline, EOL_NOENDING, HIDESTATE_SHOWN, -1);
 803
 804                                         resline++;
 805                                 }
 806
 807                                 if (latest)
 808                                 {
 809                                         if (m_arYourFile.GetCount() > yourline)
 810                                         {
 811                                                 m_YourBaseBoth.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_CONFLICTADDED, yourline, m_arYourFile.GetLineEnding(yourline), HIDESTATE_SHOWN, -1);
 812                                         }
 813                                 }
 814                                 else if ((latestresolved)||(modified)||(modifiedresolved))
 815                                 {
 816                                         m_YourBaseBoth.AddData(emptyConflictEmpty);
 817                                 }
 818                                 if (modified)
 819                                 {
 820                                         if (m_arTheirFile.GetCount() > theirline)
 821                                         {
 822                                                 m_TheirBaseBoth.AddData(m_arTheirFile.GetAt(theirline), DIFFSTATE_CONFLICTADDED, theirline, m_arTheirFile.GetLineEnding(theirline), HIDESTATE_SHOWN, -1);
 823                                         }
 824                                 }
 825                                 else if ((modifiedresolved)||(latest)||(latestresolved))
 826                                 {
 827                                         m_TheirBaseBoth.AddData(emptyConflictEmpty);
 828                                 }
 829                                 if (original)
 830                                 {
 831                                         original--;
 832                                         baseline++;
 833                                 }
 834                                 if (originalresolved)
 835                                         originalresolved--;
 836                                 if (modified)
 837                                 {
 838                                         modified--;
 839                                         theirline++;
 840                                 }
 841                                 if (modifiedresolved)
 842                                         modifiedresolved--;
 843                                 if (latest)
 844                                 {
 845                                         latest--;
 846                                         yourline++;
 847                                 }
 848                                 if (latestresolved)
 849                                         latestresolved--;
 850                         }
 851                 }
 852                 else if (tempdiff->type == svn_diff__type_diff_modified)
 853                 {
 854                         //deleted!
 855                         for (int i=0; i<tempdiff->original_length; i++)
 856                         {
 857                                 if ((m_arBaseFile.GetCount() > baseline)&&(m_arYourFile.GetCount() > yourline))
 858                                 {
 859                                         AddLines(baseline, yourline, theirline);
 860
 861                                         m_Diff3.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_THEIRSREMOVED, DIFF_EMPTYLINENUMBER, m_arBaseFile.GetLineEnding(baseline), HIDESTATE_SHOWN, -1);
 862                                         m_YourBaseBoth.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_NORMAL, yourline, m_arYourFile.GetLineEnding(yourline), HIDESTATE_SHOWN, -1);
 863                                         m_TheirBaseBoth.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_THEIRSREMOVED, DIFF_EMPTYLINENUMBER, EOL_NOENDING, HIDESTATE_SHOWN, -1);
 864
 865                                         baseline++;
 866                                         yourline++;
 867                                 }
 868                         }
 869                         //added
 870                         for (int i=0; i<tempdiff->modified_length; i++)
 871                         {
 872                                 if (m_arTheirFile.GetCount() > theirline)
 873                                 {
 874                                         AddLines(baseline, yourline, theirline);
 875
 876                                         m_Diff3.AddData(m_arTheirFile.GetAt(theirline), DIFFSTATE_THEIRSADDED, resline, m_arTheirFile.GetLineEnding(theirline), HIDESTATE_SHOWN, -1);
 877                                         m_YourBaseBoth.AddEmpty();
 878                                         m_TheirBaseBoth.AddData(m_arTheirFile.GetAt(theirline), DIFFSTATE_THEIRSADDED, theirline, m_arTheirFile.GetLineEnding(theirline), HIDESTATE_SHOWN, -1);
 879
 880                                         theirline++;
 881                                         resline++;
 882                                 }
 883                         }
 884                 }
 885                 else if (tempdiff->type == svn_diff__type_diff_latest)
 886                 {
 887                         //YOURS differs from base
 888
 889                         for (int i=0; i<tempdiff->original_length; i++)
 890                         {
 891                                 if ((m_arBaseFile.GetCount() > baseline)&&(m_arTheirFile.GetCount() > theirline))
 892                                 {
 893                                         AddLines(baseline, yourline, theirline);
 894
 895                                         m_Diff3.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_YOURSREMOVED, DIFF_EMPTYLINENUMBER, m_arBaseFile.GetLineEnding(baseline), HIDESTATE_SHOWN, -1);
 896                                         m_YourBaseBoth.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_YOURSREMOVED, DIFF_EMPTYLINENUMBER, m_arBaseFile.GetLineEnding(baseline), HIDESTATE_SHOWN, -1);
 897                                         m_TheirBaseBoth.AddData(m_arTheirFile.GetAt(theirline), DIFFSTATE_NORMAL, theirline, m_arTheirFile.GetLineEnding(theirline), HIDESTATE_HIDDEN, -1);
 898
 899                                         baseline++;
 900                                         theirline++;
 901                                 }
 902                         }
 903                         for (int i=0; i<tempdiff->latest_length; i++)
 904                         {
 905                                 if (m_arYourFile.GetCount() > yourline)
 906                                 {
 907                                         AddLines(baseline, yourline, theirline);
 908
 909                                         m_Diff3.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_YOURSADDED, resline, m_arYourFile.GetLineEnding(yourline), HIDESTATE_SHOWN, -1);
 910                                         m_YourBaseBoth.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_IDENTICALADDED, yourline, m_arYourFile.GetLineEnding(yourline), HIDESTATE_SHOWN, -1);
 911                                         m_TheirBaseBoth.AddEmpty();
 912
 913                                         yourline++;
 914                                         resline++;
 915                                 }
 916                         }
 917                 }
 918                 else
 919                 {
 920                         TRACE(_T("something bad happened during diff!\n"));
 921                 }
 922                 tempdiff = tempdiff->next;
 923
 924         } // while (tempdiff)
 925
 926         if ((options->ignore_space != svn_diff_file_ignore_space_none)||(bIgnoreCase)||(bIgnoreEOL))
 927         {
 928                 // If whitespaces are ignored, a conflict could have been missed
 929                 // We now go through all lines again and check if they're identical.
 930                 // If they're not, then that means it is a conflict, and we
 931                 // mark the conflict with the proper colors.
 932                 for (long i=0; i<m_Diff3.GetCount(); ++i)
 933                 {
 934                         DiffStates state1 = m_YourBaseBoth.GetState(i);
 935                         DiffStates state2 = m_TheirBaseBoth.GetState(i);
 936
 937                         if (((state1 == DIFFSTATE_IDENTICALADDED)||(state1 == DIFFSTATE_NORMAL))&&
 938                                 ((state2 == DIFFSTATE_IDENTICALADDED)||(state2 == DIFFSTATE_NORMAL)))
 939                         {
 940                                 LONG lineyour = m_arDiff3LinesYour.GetAt(i);
 941                                 LONG linetheir = m_arDiff3LinesTheir.GetAt(i);
 942                                 LONG linebase = m_arDiff3LinesBase.GetAt(i);
 943                                 if ((lineyour < m_arYourFile.GetCount()) &&
 944                                         (linetheir < m_arTheirFile.GetCount()) &&
 945                                         (linebase < m_arBaseFile.GetCount()))
 946                                 {
 947                                         if (((m_arYourFile.GetLineEnding(lineyour)!=m_arBaseFile.GetLineEnding(linebase))&&
 948                                                 (m_arTheirFile.GetLineEnding(linetheir)!=m_arBaseFile.GetLineEnding(linebase))&&
 949                                                 (m_arYourFile.GetLineEnding(lineyour)!=m_arTheirFile.GetLineEnding(linetheir))) ||
 950                                                 ((m_arYourFile.GetAt(lineyour).Compare(m_arBaseFile.GetAt(linebase))!=0)&&
 951                                                 (m_arTheirFile.GetAt(linetheir).Compare(m_arBaseFile.GetAt(linebase))!=0)&&
 952                                                 (m_arYourFile.GetAt(lineyour).Compare(m_arTheirFile.GetAt(linetheir))!=0)))
 953                                         {
 954                                                 m_Diff3.SetState(i, DIFFSTATE_CONFLICTED_IGNORED);
 955                                                 m_YourBaseBoth.SetState(i, DIFFSTATE_CONFLICTADDED);
 956                                                 m_TheirBaseBoth.SetState(i, DIFFSTATE_CONFLICTADDED);
 957                                         }
 958                                 }
 959                         }
 960                 }
 961         }
 962         ASSERT(m_Diff3.GetCount() == m_YourBaseBoth.GetCount());
 963         ASSERT(m_TheirBaseBoth.GetCount() == m_YourBaseBoth.GetCount());
 964
 965         TRACE(_T("done with 3-way diff\n"));
 966
 967         HideUnchangedSections(&m_Diff3, &m_YourBaseBoth, &m_TheirBaseBoth);
 968
 969         return true;
 970 }
 971
 972 void CDiffData::HideUnchangedSections(CViewData * data1, CViewData * data2, CViewData * data3) const
 973 {
 974         if (data1 == NULL)
 975                 return;
 976
 977         CRegDWORD contextLines = CRegDWORD(_T("Software\\TortoiseGitMerge\\ContextLines"), 1);
 978
 979         if (data1->GetCount() > 1)
 980         {
 981                 HIDESTATE lastHideState = data1->GetHideState(0);
 982                 if (lastHideState == HIDESTATE_HIDDEN)
 983                 {
 984                         data1->SetLineHideState(0, HIDESTATE_MARKER);
 985                         if (data2)
 986                                 data2->SetLineHideState(0, HIDESTATE_MARKER);
 987                         if (data3)
 988                                 data3->SetLineHideState(0, HIDESTATE_MARKER);
 989                 }
 990                 for (int i = 1; i < data1->GetCount(); ++i)
 991                 {
 992                         HIDESTATE hideState = data1->GetHideState(i);
 993                         if (hideState != lastHideState)
 994                         {
 995                                 if (hideState == HIDESTATE_SHOWN)
 996                                 {
 997                                         // go back and show the last 'contextLines' lines to "SHOWN"
 998                                         int lineback = i - 1;
 999                                         int stopline = lineback - (int)(DWORD)contextLines;
1000                                         while ((lineback >= 0)&&(lineback > stopline))
1001                                         {
1002                                                 data1->SetLineHideState(lineback, HIDESTATE_SHOWN);
1003                                                 if (data2)
1004                                                         data2->SetLineHideState(lineback, HIDESTATE_SHOWN);
1005                                                 if (data3)
1006                                                         data3->SetLineHideState(lineback, HIDESTATE_SHOWN);
1007                                                 lineback--;
1008                                         }
1009                                 }
1010                                 else if ((hideState == HIDESTATE_HIDDEN)&&(lastHideState != HIDESTATE_MARKER))
1011                                 {
1012                                         // go forward and show the next 'contextLines' lines to "SHOWN"
1013                                         int lineforward = i + 1;
1014                                         int stopline = lineforward + (int)(DWORD)contextLines;
1015                                         while ((lineforward < data1->GetCount())&&(lineforward < stopline))
1016                                         {
1017                                                 data1->SetLineHideState(lineforward, HIDESTATE_SHOWN);
1018                                                 if (data2)
1019                                                         data2->SetLineHideState(lineforward, HIDESTATE_SHOWN);
1020                                                 if (data3)
1021                                                         data3->SetLineHideState(lineforward, HIDESTATE_SHOWN);
1022                                                 lineforward++;
1023                                         }
1024                                         if ((lineforward < data1->GetCount())&&(data1->GetHideState(lineforward) == HIDESTATE_HIDDEN))
1025                                         {
1026                                                 data1->SetLineHideState(lineforward, HIDESTATE_MARKER);
1027                                                 if (data2)
1028                                                         data2->SetLineHideState(lineforward, HIDESTATE_MARKER);
1029                                                 if (data3)
1030                                                         data3->SetLineHideState(lineforward, HIDESTATE_MARKER);
1031                                         }
1032                                 }
1033                         }
1034                         lastHideState = hideState;
1035                 }
1036         }
1037 }
1038
1039 void CDiffData::SetCommentTokens( const CString& sLineStart, const CString& sBlockStart, const CString& sBlockEnd )
1040 {
1041         m_CommentLineStart      = sLineStart;
1042         m_CommentBlockStart     = sBlockStart;
1043         m_CommentBlockEnd       = sBlockEnd;
1044 }
1045
1046 void CDiffData::SetRegexTokens( const std::wregex& rx, const std::wstring& replacement )
1047 {
1048         m_rx                    = rx;
1049         m_replacement   = replacement;
1050 }