src/TortoiseMerge/DiffData.cpp

   1 // TortoiseMerge - a Diff/Patch program
   2
   3 // Copyright (C) 2006-2009 - 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 #include "svn_version.h"
  21 #include "svn_io.h"
  22 #include "diff.h"
  23 #include "TempFiles.h"
  24 #include "registry.h"
  25 #include "Resource.h"
  26 #include "Diffdata.h"
  27 #include "UnicodeUtils.h"
  28 #include "GitAdminDir.h"
  29 #include "svn_dso.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 {
  42         apr_initialize();
  43         svn_dso_initialize2();
  44         g_GitAdminDir.Init();
  45
  46         m_bBlame = false;
  47
  48         m_sPatchOriginal = _T(": original");
  49         m_sPatchPatched = _T(": patched");
  50 }
  51
  52 CDiffData::~CDiffData(void)
  53 {
  54         g_GitAdminDir.Close();
  55         apr_terminate();
  56 }
  57
  58 int CDiffData::GetLineCount()
  59 {
  60         int count = 0;
  61         count = (int)m_arBaseFile.GetCount();
  62         count = (int)(count > m_arTheirFile.GetCount() ? count : m_arTheirFile.GetCount());
  63         count = (int)(count > m_arYourFile.GetCount() ? count : m_arYourFile.GetCount());
  64         return count;
  65 }
  66
  67 int CDiffData::GetLineActualLength(int index)
  68 {
  69         int count = 0;
  70         if (index < m_arBaseFile.GetCount())
  71                 count = (count > m_arBaseFile.GetAt(index).GetLength() ? count : m_arBaseFile.GetAt(index).GetLength());
  72         if (index < m_arTheirFile.GetCount())
  73                 count = (count > m_arTheirFile.GetAt(index).GetLength() ? count : m_arTheirFile.GetAt(index).GetLength());
  74         if (index < m_arYourFile.GetCount())
  75                 count = (count > m_arYourFile.GetAt(index).GetLength() ? count : m_arYourFile.GetAt(index).GetLength());
  76         return count;
  77 }
  78
  79 LPCTSTR CDiffData::GetLineChars(int index)
  80 {
  81         if (index < m_arBaseFile.GetCount())
  82                 return m_arBaseFile.GetAt(index);
  83         if (index < m_arTheirFile.GetCount())
  84                 return m_arTheirFile.GetAt(index);
  85         if (index < m_arYourFile.GetCount())
  86                 return m_arYourFile.GetAt(index);
  87         return NULL;
  88 }
  89
  90 BOOL CDiffData::Load()
  91 {
  92         CString sConvertedBaseFilename, sConvertedTheirFilename, sConvertedYourFilename;
  93         apr_pool_t * pool;
  94
  95         apr_pool_create_ex (&pool, NULL, abort_on_pool_failure, NULL);
  96
  97         m_arBaseFile.RemoveAll();
  98         m_arYourFile.RemoveAll();
  99         m_arTheirFile.RemoveAll();
 100
 101         m_YourBaseBoth.Clear();
 102         m_YourBaseLeft.Clear();
 103         m_YourBaseRight.Clear();
 104
 105         m_TheirBaseBoth.Clear();
 106         m_TheirBaseLeft.Clear();
 107         m_TheirBaseRight.Clear();
 108
 109         m_Diff3.Clear();
 110
 111         m_arDiff3LinesBase.RemoveAll();
 112         m_arDiff3LinesYour.RemoveAll();
 113         m_arDiff3LinesTheir.RemoveAll();
 114
 115         CTempFiles tempfiles;
 116         CRegDWORD regIgnoreWS = CRegDWORD(_T("Software\\TortoiseMerge\\IgnoreWS"));
 117         CRegDWORD regIgnoreEOL = CRegDWORD(_T("Software\\TortoiseMerge\\IgnoreEOL"), TRUE);
 118         CRegDWORD regIgnoreCase = CRegDWORD(_T("Software\\TortoiseMerge\\CaseInsensitive"), FALSE);
 119         DWORD dwIgnoreWS = regIgnoreWS;
 120         bool bIgnoreEOL = ((DWORD)regIgnoreEOL)!=0;
 121         BOOL bIgnoreCase = ((DWORD)regIgnoreCase)!=0;
 122
 123         // The Subversion diff API only can ignore whitespaces and eol styles.
 124         // It also can only handle one-byte charsets.
 125         // To ignore case changes or to handle UTF-16 files, we have to
 126         // save the original file in UTF-8 and/or the letters changed to lowercase
 127         // so the Subversion diff can handle those.
 128         sConvertedBaseFilename = m_baseFile.GetFilename();
 129         sConvertedYourFilename = m_yourFile.GetFilename();
 130         sConvertedTheirFilename = m_theirFile.GetFilename();
 131         if (IsBaseFileInUse())
 132         {
 133                 if (!m_arBaseFile.Load(m_baseFile.GetFilename()))
 134                 {
 135                         m_sError = m_arBaseFile.GetErrorString();
 136                         return FALSE;
 137                 }
 138                 if ((bIgnoreCase)||(m_arBaseFile.GetUnicodeType() == CFileTextLines::UNICODE_LE))
 139                 {
 140                         CFileTextLines converted(m_arBaseFile);
 141                         sConvertedBaseFilename = tempfiles.GetTempFilePath();
 142                         converted.Save(sConvertedBaseFilename, m_arBaseFile.GetUnicodeType() == CFileTextLines::UNICODE_LE, dwIgnoreWS, bIgnoreCase, m_bBlame);
 143                 }
 144         }
 145
 146         if (IsTheirFileInUse())
 147         {
 148                 // m_arBaseFile.GetCount() is passed as a hint for the number of lines in this file
 149                 // It's a fair guess that the files will be roughly the same size
 150                 if (!m_arTheirFile.Load(m_theirFile.GetFilename(),m_arBaseFile.GetCount()))
 151                 {
 152                         m_sError = m_arTheirFile.GetErrorString();
 153                         return FALSE;
 154                 }
 155                 if ((bIgnoreCase)||(m_arTheirFile.GetUnicodeType() == CFileTextLines::UNICODE_LE))
 156                 {
 157                         CFileTextLines converted(m_arTheirFile);
 158                         sConvertedTheirFilename = tempfiles.GetTempFilePath();
 159                         converted.Save(sConvertedTheirFilename, m_arTheirFile.GetUnicodeType() == CFileTextLines::UNICODE_LE, dwIgnoreWS, bIgnoreCase, m_bBlame);
 160                 }
 161         }
 162
 163         if (IsYourFileInUse())
 164         {
 165                 // m_arBaseFile.GetCount() is passed as a hint for the number of lines in this file
 166                 // It's a fair guess that the files will be roughly the same size
 167                 if (!m_arYourFile.Load(m_yourFile.GetFilename(),m_arBaseFile.GetCount()))
 168                 {
 169                         m_sError = m_arYourFile.GetErrorString();
 170                         return FALSE;
 171                 }
 172                 if ((bIgnoreCase)||(m_arYourFile.GetUnicodeType() == CFileTextLines::UNICODE_LE))
 173                 {
 174                         CFileTextLines converted(m_arYourFile);
 175                         sConvertedYourFilename = tempfiles.GetTempFilePath();
 176                         converted.Save(sConvertedYourFilename, m_arYourFile.GetUnicodeType() == CFileTextLines::UNICODE_LE, dwIgnoreWS, bIgnoreCase, m_bBlame);
 177                 }
 178         }
 179
 180         // Calculate the number of lines in the largest of the three files
 181         int lengthHint = max(m_arBaseFile.GetCount(), m_arTheirFile.GetCount());
 182         lengthHint = max(lengthHint, m_arYourFile.GetCount());
 183
 184         try
 185         {
 186                 m_YourBaseBoth.Reserve(lengthHint);
 187                 m_YourBaseLeft.Reserve(lengthHint);
 188                 m_YourBaseRight.Reserve(lengthHint);
 189
 190                 m_TheirBaseBoth.Reserve(lengthHint);
 191                 m_TheirBaseLeft.Reserve(lengthHint);
 192                 m_TheirBaseRight.Reserve(lengthHint);
 193
 194                 m_arDiff3LinesBase.Reserve(lengthHint);
 195                 m_arDiff3LinesYour.Reserve(lengthHint);
 196                 m_arDiff3LinesTheir.Reserve(lengthHint);
 197         }
 198         catch (CMemoryException* e)
 199         {
 200                 e->GetErrorMessage(m_sError.GetBuffer(255), 255);
 201                 m_sError.ReleaseBuffer();
 202                 return FALSE;
 203         }
 204
 205         // Is this a two-way diff?
 206         if (IsBaseFileInUse() && IsYourFileInUse() && !IsTheirFileInUse())
 207         {
 208                 if (!DoTwoWayDiff(sConvertedBaseFilename, sConvertedYourFilename, dwIgnoreWS, bIgnoreEOL, pool))
 209                 {
 210                         apr_pool_destroy (pool);                                        // free the allocated memory
 211                         return FALSE;
 212                 }
 213         }
 214
 215         if (IsBaseFileInUse() && IsTheirFileInUse() && !IsYourFileInUse())
 216         {
 217                 ASSERT(FALSE);
 218         }
 219
 220         if (IsBaseFileInUse() && IsTheirFileInUse() && IsYourFileInUse())
 221         {
 222                 m_Diff3.Reserve(lengthHint);
 223
 224                 if (!DoThreeWayDiff(sConvertedBaseFilename, sConvertedYourFilename, sConvertedTheirFilename, dwIgnoreWS, bIgnoreEOL, !!bIgnoreCase, pool))
 225                 {
 226                         apr_pool_destroy (pool);                                        // free the allocated memory
 227                         return FALSE;
 228                 }
 229         }
 230
 231         apr_pool_destroy (pool);                                        // free the allocated memory
 232         return TRUE;
 233 }
 234
 235
 236 bool
 237 CDiffData::DoTwoWayDiff(const CString& sBaseFilename, const CString& sYourFilename, DWORD dwIgnoreWS, bool bIgnoreEOL, apr_pool_t * pool)
 238 {
 239         // convert CString filenames (UTF-16 or ANSI) to UTF-8
 240         CStringA sBaseFilenameUtf8 = CUnicodeUtils::GetUTF8(sBaseFilename);
 241         CStringA sYourFilenameUtf8 = CUnicodeUtils::GetUTF8(sYourFilename);
 242
 243         svn_diff_t * diffYourBase = NULL;
 244         svn_error_t * svnerr = NULL;
 245         svn_diff_file_options_t * options = svn_diff_file_options_create(pool);
 246         options->ignore_eol_style = bIgnoreEOL;
 247         options->ignore_space = svn_diff_file_ignore_space_none;
 248         switch (dwIgnoreWS)
 249         {
 250         case 0:
 251                 options->ignore_space = svn_diff_file_ignore_space_none;
 252                 break;
 253         case 1:
 254                 options->ignore_space = svn_diff_file_ignore_space_all;
 255                 break;
 256         case 2:
 257                 options->ignore_space = svn_diff_file_ignore_space_change;
 258                 break;
 259         }
 260
 261         svnerr = svn_diff_file_diff_2(&diffYourBase, sBaseFilenameUtf8, sYourFilenameUtf8, options, pool);
 262         if (svnerr)
 263         {
 264                 TRACE(_T("diff-error in CDiffData::Load()\n"));
 265                 CString sMsg = CString(svnerr->message);
 266                 while (svnerr->child)
 267                 {
 268                         svnerr = svnerr->child;
 269                         sMsg += _T("\n");
 270                         sMsg += CString(svnerr->message);
 271                 }
 272                 m_sError.Format(IDS_ERR_DIFF_DIFF, (LPCTSTR)sMsg);
 273                 svn_error_clear(svnerr);
 274                 return false;
 275         }
 276         svn_diff_t * tempdiff = diffYourBase;
 277         LONG baseline = 0;
 278         LONG yourline = 0;
 279
 280         while (tempdiff)
 281         {
 282                 for (int i=0; i<tempdiff->original_length; i++)
 283                 {
 284                         if (baseline >= m_arBaseFile.GetCount())
 285                         {
 286                                 m_sError.LoadString(IDS_ERR_DIFF_NEWLINES);
 287                                 return false;
 288                         }
 289                         const CString& sCurrentBaseLine = m_arBaseFile.GetAt(baseline);
 290                         EOL endingBase = m_arBaseFile.GetLineEnding(baseline);
 291                         if (tempdiff->type == svn_diff__type_common)
 292                         {
 293                                 if (yourline >= m_arYourFile.GetCount())
 294                                 {
 295                                         m_sError.LoadString(IDS_ERR_DIFF_NEWLINES);
 296                                         return false;
 297                                 }
 298                                 const CString& sCurrentYourLine = m_arYourFile.GetAt(yourline);
 299                                 EOL endingYours = m_arYourFile.GetLineEnding(yourline);
 300                                 if (sCurrentBaseLine != sCurrentYourLine)
 301                                 {
 302                                         if (dwIgnoreWS == 2 || dwIgnoreWS == 3)
 303                                         {
 304                                                 CString s1 = m_arBaseFile.GetAt(baseline);
 305                                                 CString s2 = sCurrentYourLine;
 306
 307                                                 if ( dwIgnoreWS == 2 )
 308                                                 {
 309                                                         s1.TrimLeft(_T(" \t"));
 310                                                         s2.TrimLeft(_T(" \t"));
 311                                                 }
 312                                                 else
 313                                                 {
 314                                                         s1.TrimRight(_T(" \t"));
 315                                                         s2.TrimRight(_T(" \t"));
 316                                                 }
 317
 318                                                 if (s1 != s2)
 319                                                 {
 320                                                         // one-pane view: two lines, one 'removed' and one 'added'
 321                                                         m_YourBaseBoth.AddData(sCurrentBaseLine, DIFFSTATE_REMOVEDWHITESPACE, yourline, endingBase);
 322                                                         m_YourBaseBoth.AddData(sCurrentYourLine, DIFFSTATE_ADDEDWHITESPACE, yourline, endingYours);
 323                                                 }
 324                                                 else
 325                                                 {
 326                                                         m_YourBaseBoth.AddData(sCurrentBaseLine, DIFFSTATE_NORMAL, yourline, endingBase);
 327                                                 }
 328                                         }
 329                                         else if (dwIgnoreWS == 0)
 330                                         {
 331                                                 m_YourBaseBoth.AddData(sCurrentBaseLine, DIFFSTATE_REMOVEDWHITESPACE, yourline, endingBase);
 332                                                 m_YourBaseBoth.AddData(sCurrentYourLine, DIFFSTATE_ADDEDWHITESPACE, yourline, endingYours);
 333                                         }
 334                                         else
 335                                         {
 336                                                 m_YourBaseBoth.AddData(sCurrentBaseLine, DIFFSTATE_NORMAL, yourline, endingBase);
 337                                         }
 338                                 }
 339                                 else
 340                                 {
 341                                         m_YourBaseBoth.AddData(sCurrentBaseLine, DIFFSTATE_NORMAL, yourline, endingBase);
 342                                 }
 343                                 yourline++;             //in both files
 344                         }
 345                         else
 346                         {
 347                                 m_YourBaseBoth.AddData(sCurrentBaseLine, DIFFSTATE_REMOVED, yourline, endingBase);
 348                         }
 349                         baseline++;
 350                 }
 351                 if (tempdiff->type == svn_diff__type_diff_modified)
 352                 {
 353                         for (int i=0; i<tempdiff->modified_length; i++)
 354                         {
 355                                 if (m_arYourFile.GetCount() > yourline)
 356                                 {
 357                                         m_YourBaseBoth.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_ADDED, yourline, m_arYourFile.GetLineEnding(yourline));
 358                                 }
 359                                 yourline++;
 360                         }
 361                 }
 362                 tempdiff = tempdiff->next;
 363         }
 364
 365         tempdiff = diffYourBase;
 366         baseline = 0;
 367         yourline = 0;
 368         while (tempdiff)
 369         {
 370                 if (tempdiff->type == svn_diff__type_common)
 371                 {
 372                         for (int i=0; i<tempdiff->original_length; i++)
 373                         {
 374                                 const CString& sCurrentYourLine = m_arYourFile.GetAt(yourline);
 375                                 EOL endingYours = m_arYourFile.GetLineEnding(yourline);
 376                                 const CString& sCurrentBaseLine = m_arBaseFile.GetAt(baseline);
 377                                 EOL endingBase = m_arBaseFile.GetLineEnding(baseline);
 378                                 if (sCurrentBaseLine != sCurrentYourLine)
 379                                 {
 380                                         if (dwIgnoreWS == 2 || dwIgnoreWS == 3)
 381                                         {
 382                                                 CString s1 = sCurrentBaseLine;
 383                                                 CString s2 = sCurrentYourLine;
 384                                                 if ( dwIgnoreWS == 2 )
 385                                                 {
 386                                                         s1 = s1.TrimLeft(_T(" \t"));
 387                                                         s2 = s2.TrimLeft(_T(" \t"));
 388                                                 }
 389                                                 else
 390                                                 {
 391                                                         s1 = s1.TrimRight(_T(" \t"));
 392                                                         s2 = s2.TrimRight(_T(" \t"));
 393                                                 }
 394
 395                                                 if (s1 != s2)
 396                                                 {
 397                                                         m_YourBaseLeft.AddData(sCurrentBaseLine, DIFFSTATE_WHITESPACE, baseline, endingBase);
 398                                                         m_YourBaseRight.AddData(sCurrentYourLine, DIFFSTATE_WHITESPACE, yourline, endingYours);
 399                                                 }
 400                                                 else
 401                                                 {
 402                                                         m_YourBaseLeft.AddData(sCurrentBaseLine, DIFFSTATE_NORMAL, baseline, endingBase);
 403                                                         m_YourBaseRight.AddData(sCurrentYourLine, DIFFSTATE_NORMAL, yourline, endingYours);
 404                                                 }
 405                                         }
 406                                         else if (dwIgnoreWS == 0)
 407                                         {
 408                                                 m_YourBaseLeft.AddData(sCurrentBaseLine, DIFFSTATE_WHITESPACE, baseline, endingBase);
 409                                                 m_YourBaseRight.AddData(sCurrentYourLine, DIFFSTATE_WHITESPACE, yourline, endingYours);
 410                                         }
 411                                         else
 412                                         {
 413                                                 m_YourBaseLeft.AddData(sCurrentBaseLine, DIFFSTATE_NORMAL, baseline, endingBase);
 414                                                 m_YourBaseRight.AddData(sCurrentYourLine, DIFFSTATE_NORMAL, yourline, endingYours);
 415                                         }
 416                                 }
 417                                 else
 418                                 {
 419                                         m_YourBaseLeft.AddData(sCurrentBaseLine, DIFFSTATE_NORMAL, baseline, endingBase);
 420                                         m_YourBaseRight.AddData(sCurrentYourLine, DIFFSTATE_NORMAL, yourline, endingYours);
 421                                 }
 422                                 baseline++;
 423                                 yourline++;
 424                         }
 425                 }
 426                 if (tempdiff->type == svn_diff__type_diff_modified)
 427                 {
 428                         apr_off_t original_length = tempdiff->original_length;
 429                         for (int i=0; i<tempdiff->modified_length; i++)
 430                         {
 431                                 if (m_arYourFile.GetCount() > yourline)
 432                                 {
 433                                         EOL endingYours = m_arYourFile.GetLineEnding(yourline);
 434                                         if (original_length-- <= 0)
 435                                         {
 436                                                 m_YourBaseLeft.AddData(_T(""), DIFFSTATE_EMPTY, DIFF_EMPTYLINENUMBER, EOL_NOENDING);
 437                                                 m_YourBaseRight.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_ADDED, yourline, endingYours);
 438                                         }
 439                                         else
 440                                         {
 441                                                 EOL endingBase = m_arBaseFile.GetLineEnding(baseline);
 442                                                 m_YourBaseLeft.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_REMOVED, baseline, endingBase);
 443                                                 m_YourBaseRight.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_ADDED, yourline, endingYours);
 444                                                 baseline++;
 445                                         }
 446                                         yourline++;
 447                                 }
 448                         }
 449                         apr_off_t modified_length = tempdiff->modified_length;
 450                         for (int i=0; i<tempdiff->original_length; i++)
 451                         {
 452                                 if (modified_length-- <= 0)
 453                                 {
 454                                         if (m_arBaseFile.GetCount() > baseline)
 455                                         {
 456                                                 EOL endingBase = m_arBaseFile.GetLineEnding(baseline);
 457                                                 m_YourBaseLeft.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_REMOVED, baseline, endingBase);
 458                                                 m_YourBaseRight.AddData(_T(""), DIFFSTATE_EMPTY, DIFF_EMPTYLINENUMBER, EOL_NOENDING);
 459                                                 baseline++;
 460                                         }
 461                                 }
 462                         }
 463                 }
 464                 tempdiff = tempdiff->next;
 465         }
 466         TRACE(_T("done with 2-way diff\n"));
 467
 468         return true;
 469 }
 470
 471 bool
 472 CDiffData::DoThreeWayDiff(const CString& sBaseFilename, const CString& sYourFilename, const CString& sTheirFilename, DWORD dwIgnoreWS, bool bIgnoreEOL, bool bIgnoreCase, apr_pool_t * pool)
 473 {
 474         // convert CString filenames (UTF-16 or ANSI) to UTF-8
 475         CStringA sBaseFilenameUtf8  = CUnicodeUtils::GetUTF8(sBaseFilename);
 476         CStringA sYourFilenameUtf8  = CUnicodeUtils::GetUTF8(sYourFilename);
 477         CStringA sTheirFilenameUtf8 = CUnicodeUtils::GetUTF8(sTheirFilename);
 478         svn_diff_t * diffTheirYourBase = NULL;
 479         svn_diff_file_options_t * options = svn_diff_file_options_create(pool);
 480         options->ignore_eol_style = bIgnoreEOL;
 481         options->ignore_space = svn_diff_file_ignore_space_none;
 482         switch (dwIgnoreWS)
 483         {
 484         case 0:
 485                 options->ignore_space = svn_diff_file_ignore_space_none;
 486                 break;
 487         case 1:
 488                 options->ignore_space = svn_diff_file_ignore_space_all;
 489                 break;
 490         case 2:
 491                 options->ignore_space = svn_diff_file_ignore_space_change;
 492                 break;
 493         }
 494         svn_error_t * svnerr = svn_diff_file_diff3_2(&diffTheirYourBase, sBaseFilenameUtf8, sTheirFilenameUtf8, sYourFilenameUtf8, options, pool);
 495         if (svnerr)
 496         {
 497                 TRACE(_T("diff-error in CDiffData::Load()\n"));
 498                 CString sMsg = CString(svnerr->message);
 499                 while (svnerr->child)
 500                 {
 501                         svnerr = svnerr->child;
 502                         sMsg += _T("\n");
 503                         sMsg += CString(svnerr->message);
 504                 }
 505                 m_sError.Format(IDS_ERR_DIFF_DIFF, (LPCTSTR)sMsg);
 506                 svn_error_clear(svnerr);
 507                 return false;
 508         }
 509
 510         svn_diff_t * tempdiff = diffTheirYourBase;
 511         LONG baseline = 0;
 512         LONG yourline = 0;
 513         LONG theirline = 0;
 514         LONG resline = 0;
 515         while (tempdiff)
 516         {
 517                 if (tempdiff->type == svn_diff__type_common)
 518                 {
 519                         ASSERT((tempdiff->latest_length == tempdiff->modified_length) && (tempdiff->modified_length == tempdiff->original_length));
 520                         for (int i=0; i<tempdiff->original_length; i++)
 521                         {
 522                                 if ((m_arYourFile.GetCount() > yourline)&&(m_arTheirFile.GetCount() > theirline))
 523                                 {
 524                                         m_Diff3.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_NORMAL, resline, m_arYourFile.GetLineEnding(yourline));
 525
 526                                         m_arDiff3LinesBase.Add(baseline);
 527                                         m_arDiff3LinesYour.Add(yourline);
 528                                         m_arDiff3LinesTheir.Add(theirline);
 529
 530                                         m_YourBaseBoth.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_NORMAL, yourline, m_arYourFile.GetLineEnding(yourline));
 531                                         m_TheirBaseBoth.AddData(m_arTheirFile.GetAt(theirline), DIFFSTATE_NORMAL, theirline, m_arTheirFile.GetLineEnding(theirline));
 532
 533                                         baseline++;
 534                                         yourline++;
 535                                         theirline++;
 536                                         resline++;
 537                                 }
 538                         }
 539                 }
 540                 else if (tempdiff->type == svn_diff__type_diff_common)
 541                 {
 542                         ASSERT(tempdiff->latest_length == tempdiff->modified_length);
 543                         //both theirs and yours have lines replaced
 544                         for (int i=0; i<tempdiff->original_length; i++)
 545                         {
 546                                 if (m_arBaseFile.GetCount() > baseline)
 547                                 {
 548                                         m_Diff3.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_IDENTICALREMOVED, DIFF_EMPTYLINENUMBER, m_arBaseFile.GetLineEnding(baseline));
 549
 550                                         m_arDiff3LinesBase.Add(baseline);
 551                                         m_arDiff3LinesYour.Add(yourline);
 552                                         m_arDiff3LinesTheir.Add(theirline);
 553
 554                                         m_YourBaseBoth.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_IDENTICALREMOVED, DIFF_EMPTYLINENUMBER, EOL_NOENDING);
 555                                         m_TheirBaseBoth.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_IDENTICALREMOVED, DIFF_EMPTYLINENUMBER, EOL_NOENDING);
 556
 557                                         baseline++;
 558                                 }
 559                         }
 560                         for (int i=0; i<tempdiff->modified_length; i++)
 561                         {
 562                                 if ((m_arYourFile.GetCount() > yourline)&&(m_arTheirFile.GetCount() > theirline))
 563                                 {
 564                                         m_Diff3.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_IDENTICALADDED, resline, m_arYourFile.GetLineEnding(yourline));
 565
 566                                         m_arDiff3LinesBase.Add(baseline);
 567                                         m_arDiff3LinesYour.Add(yourline);
 568                                         m_arDiff3LinesTheir.Add(theirline);
 569
 570                                         m_YourBaseBoth.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_IDENTICALADDED, yourline, m_arYourFile.GetLineEnding(yourline));
 571                                         m_TheirBaseBoth.AddData(m_arTheirFile.GetAt(theirline), DIFFSTATE_IDENTICALADDED, resline, m_arTheirFile.GetLineEnding(theirline));
 572
 573                                         yourline++;
 574                                         theirline++;
 575                                         resline++;
 576                                 }
 577                         }
 578                 }
 579                 else if (tempdiff->type == svn_diff__type_conflict)
 580                 {
 581                         apr_off_t length = max(tempdiff->original_length, tempdiff->modified_length);
 582                         length = max(tempdiff->latest_length, length);
 583                         apr_off_t original = tempdiff->original_length;
 584                         apr_off_t modified = tempdiff->modified_length;
 585                         apr_off_t latest = tempdiff->latest_length;
 586
 587                         apr_off_t originalresolved = 0;
 588                         apr_off_t modifiedresolved = 0;
 589                         apr_off_t latestresolved = 0;
 590
 591                         LONG base = baseline;
 592                         LONG your = yourline;
 593                         LONG their = theirline;
 594                         if (tempdiff->resolved_diff)
 595                         {
 596                                 originalresolved = tempdiff->resolved_diff->original_length;
 597                                 modifiedresolved = tempdiff->resolved_diff->modified_length;
 598                                 latestresolved = tempdiff->resolved_diff->latest_length;
 599                         }
 600                         for (int i=0; i<length; i++)
 601                         {
 602                                 if (original)
 603                                 {
 604                                         if (m_arBaseFile.GetCount() > baseline)
 605                                         {
 606                                                 m_Diff3.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_IDENTICALREMOVED, DIFF_EMPTYLINENUMBER, m_arBaseFile.GetLineEnding(baseline));
 607
 608                                                 m_arDiff3LinesBase.Add(baseline);
 609                                                 m_arDiff3LinesYour.Add(yourline);
 610                                                 m_arDiff3LinesTheir.Add(theirline);
 611                                         }
 612                                 }
 613                                 else if ((originalresolved)||((modifiedresolved)&&(latestresolved)))
 614                                 {
 615                                         m_Diff3.AddData(_T(""), DIFFSTATE_IDENTICALREMOVED, DIFF_EMPTYLINENUMBER, EOL_NOENDING);
 616
 617                                         m_arDiff3LinesBase.Add(baseline);
 618                                         m_arDiff3LinesYour.Add(yourline);
 619                                         m_arDiff3LinesTheir.Add(theirline);
 620
 621                                 }
 622                                 if ((latest)&&(original))
 623                                 {
 624                                         if (m_arBaseFile.GetCount() > baseline)
 625                                         {
 626                                                 m_YourBaseBoth.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_IDENTICALREMOVED, DIFF_EMPTYLINENUMBER, m_arBaseFile.GetLineEnding(baseline));
 627                                         }
 628                                 }
 629                                 else
 630                                 {
 631                                         if (original)
 632                                         {
 633                                                 if (m_arBaseFile.GetCount() > baseline)
 634                                                 {
 635                                                         m_YourBaseBoth.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_IDENTICALREMOVED, DIFF_EMPTYLINENUMBER, m_arBaseFile.GetLineEnding(baseline));
 636                                                 }
 637                                         }
 638                                         else if ((latestresolved)&&(modifiedresolved))
 639                                         {
 640                                                 m_YourBaseBoth.AddData(_T(""), DIFFSTATE_IDENTICALREMOVED, DIFF_EMPTYLINENUMBER, EOL_NOENDING);
 641                                         }
 642                                 }
 643                                 if ((modified)&&(original))
 644                                 {
 645                                         if (m_arBaseFile.GetCount() > baseline)
 646                                         {
 647                                                 m_TheirBaseBoth.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_IDENTICALREMOVED, DIFF_EMPTYLINENUMBER, m_arBaseFile.GetLineEnding(baseline));
 648                                         }
 649                                 }
 650                                 else
 651                                 {
 652                                         if (original)
 653                                         {
 654                                                 if (m_arBaseFile.GetCount() > baseline)
 655                                                 {
 656                                                         m_TheirBaseBoth.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_IDENTICALREMOVED, DIFF_EMPTYLINENUMBER, m_arBaseFile.GetLineEnding(baseline));
 657                                                 }
 658                                         }
 659                                         else if ((modifiedresolved)&&(latestresolved))
 660                                         {
 661                                                 m_TheirBaseBoth.AddData(_T(""), DIFFSTATE_IDENTICALREMOVED, DIFF_EMPTYLINENUMBER, EOL_NOENDING);
 662                                         }
 663                                 }
 664                                 if (original)
 665                                 {
 666                                         original--;
 667                                         baseline++;
 668                                 }
 669                                 if (originalresolved)
 670                                         originalresolved--;
 671
 672                                 if (modified)
 673                                 {
 674                                         modified--;
 675                                         theirline++;
 676                                 }
 677                                 if (modifiedresolved)
 678                                         modifiedresolved--;
 679                                 if (latest)
 680                                 {
 681                                         latest--;
 682                                         yourline++;
 683                                 }
 684                                 if (latestresolved)
 685                                         latestresolved--;
 686                         }
 687                         original = tempdiff->original_length;
 688                         modified = tempdiff->modified_length;
 689                         latest = tempdiff->latest_length;
 690                         baseline = base;
 691                         yourline = your;
 692                         theirline = their;
 693                         if (tempdiff->resolved_diff)
 694                         {
 695                                 originalresolved = tempdiff->resolved_diff->original_length;
 696                                 modifiedresolved = tempdiff->resolved_diff->modified_length;
 697                                 latestresolved = tempdiff->resolved_diff->latest_length;
 698                         }
 699                         for (int i=0; i<length; i++)
 700                         {
 701                                 if ((latest)||(modified))
 702                                 {
 703                                         m_Diff3.AddData(_T(""), DIFFSTATE_CONFLICTED, resline, EOL_NOENDING);
 704
 705                                         m_arDiff3LinesBase.Add(baseline);
 706                                         m_arDiff3LinesYour.Add(yourline);
 707                                         m_arDiff3LinesTheir.Add(theirline);
 708
 709                                         resline++;
 710                                 }
 711
 712                                 if (latest)
 713                                 {
 714                                         if (m_arYourFile.GetCount() > yourline)
 715                                         {
 716                                                 m_YourBaseBoth.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_CONFLICTADDED, yourline, m_arYourFile.GetLineEnding(yourline));
 717                                         }
 718                                 }
 719                                 else if ((latestresolved)||(modified)||(modifiedresolved))
 720                                 {
 721                                         m_YourBaseBoth.AddData(_T(""), DIFFSTATE_CONFLICTEMPTY, DIFF_EMPTYLINENUMBER, EOL_NOENDING);
 722                                 }
 723                                 if (modified)
 724                                 {
 725                                         if (m_arTheirFile.GetCount() > theirline)
 726                                         {
 727                                                 m_TheirBaseBoth.AddData(m_arTheirFile.GetAt(theirline), DIFFSTATE_CONFLICTADDED, theirline, m_arTheirFile.GetLineEnding(theirline));
 728                                         }
 729                                 }
 730                                 else if ((modifiedresolved)||(latest)||(latestresolved))
 731                                 {
 732                                         m_TheirBaseBoth.AddData(_T(""), DIFFSTATE_CONFLICTEMPTY, DIFF_EMPTYLINENUMBER, EOL_NOENDING);
 733                                 }
 734                                 if (original)
 735                                 {
 736                                         original--;
 737                                         baseline++;
 738                                 }
 739                                 if (originalresolved)
 740                                         originalresolved--;
 741                                 if (modified)
 742                                 {
 743                                         modified--;
 744                                         theirline++;
 745                                 }
 746                                 if (modifiedresolved)
 747                                         modifiedresolved--;
 748                                 if (latest)
 749                                 {
 750                                         latest--;
 751                                         yourline++;
 752                                 }
 753                                 if (latestresolved)
 754                                         latestresolved--;
 755                         }
 756                 }
 757                 else if (tempdiff->type == svn_diff__type_diff_modified)
 758                 {
 759                         //deleted!
 760                         for (int i=0; i<tempdiff->original_length; i++)
 761                         {
 762                                 if ((m_arBaseFile.GetCount() > baseline)&&(m_arYourFile.GetCount() > yourline))
 763                                 {
 764                                         m_Diff3.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_THEIRSREMOVED, DIFF_EMPTYLINENUMBER, m_arBaseFile.GetLineEnding(baseline));
 765
 766                                         m_arDiff3LinesBase.Add(baseline);
 767                                         m_arDiff3LinesYour.Add(yourline);
 768                                         m_arDiff3LinesTheir.Add(theirline);
 769
 770                                         m_YourBaseBoth.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_NORMAL, yourline, m_arYourFile.GetLineEnding(yourline));
 771                                         m_TheirBaseBoth.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_THEIRSREMOVED, DIFF_EMPTYLINENUMBER, EOL_NOENDING);
 772                                         baseline++;
 773                                         yourline++;
 774                                 }
 775                         }
 776                         //added
 777                         for (int i=0; i<tempdiff->modified_length; i++)
 778                         {
 779                                 if (m_arTheirFile.GetCount() > theirline)
 780                                 {
 781                                         m_Diff3.AddData(m_arTheirFile.GetAt(theirline), DIFFSTATE_THEIRSADDED, resline, m_arTheirFile.GetLineEnding(theirline));
 782
 783                                         m_arDiff3LinesBase.Add(baseline);
 784                                         m_arDiff3LinesYour.Add(yourline);
 785                                         m_arDiff3LinesTheir.Add(theirline);
 786
 787                                         m_YourBaseBoth.AddData(_T(""), DIFFSTATE_EMPTY, DIFF_EMPTYLINENUMBER, EOL_NOENDING);
 788                                         m_TheirBaseBoth.AddData(m_arTheirFile.GetAt(theirline), DIFFSTATE_THEIRSADDED, theirline, m_arTheirFile.GetLineEnding(theirline));
 789
 790                                         theirline++;
 791                                         resline++;
 792                                 }
 793                         }
 794                 }
 795                 else if (tempdiff->type == svn_diff__type_diff_latest)
 796                 {
 797                         //YOURS differs from base
 798
 799                         for (int i=0; i<tempdiff->original_length; i++)
 800                         {
 801                                 if ((m_arBaseFile.GetCount() > baseline)&&(m_arTheirFile.GetCount() > theirline))
 802                                 {
 803                                         m_Diff3.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_YOURSREMOVED, DIFF_EMPTYLINENUMBER, m_arBaseFile.GetLineEnding(baseline));
 804
 805                                         m_arDiff3LinesBase.Add(baseline);
 806                                         m_arDiff3LinesYour.Add(yourline);
 807                                         m_arDiff3LinesTheir.Add(theirline);
 808
 809                                         m_YourBaseBoth.AddData(m_arBaseFile.GetAt(baseline), DIFFSTATE_YOURSREMOVED, DIFF_EMPTYLINENUMBER, m_arBaseFile.GetLineEnding(baseline));
 810                                         m_TheirBaseBoth.AddData(m_arTheirFile.GetAt(theirline), DIFFSTATE_NORMAL, theirline, m_arTheirFile.GetLineEnding(theirline));
 811
 812                                         baseline++;
 813                                         theirline++;
 814                                 }
 815                         }
 816                         for (int i=0; i<tempdiff->latest_length; i++)
 817                         {
 818                                 if (m_arYourFile.GetCount() > yourline)
 819                                 {
 820                                         m_Diff3.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_YOURSADDED, resline, m_arYourFile.GetLineEnding(yourline));
 821
 822                                         m_arDiff3LinesBase.Add(baseline);
 823                                         m_arDiff3LinesYour.Add(yourline);
 824                                         m_arDiff3LinesTheir.Add(theirline);
 825
 826                                         m_YourBaseBoth.AddData(m_arYourFile.GetAt(yourline), DIFFSTATE_IDENTICALADDED, yourline, m_arYourFile.GetLineEnding(yourline));
 827                                         m_TheirBaseBoth.AddData(_T(""), DIFFSTATE_EMPTY, DIFF_EMPTYLINENUMBER, EOL_NOENDING);
 828
 829                                         yourline++;
 830                                         resline++;
 831                                 }
 832                         }
 833                 }
 834                 else
 835                 {
 836                         TRACE(_T("something bad happened during diff!\n"));
 837                 }
 838                 tempdiff = tempdiff->next;
 839
 840         } // while (tempdiff)
 841
 842         if ((options->ignore_space != svn_diff_file_ignore_space_none)||(bIgnoreCase)||(bIgnoreEOL))
 843         {
 844                 // If whitespaces are ignored, a conflict could have been missed
 845                 // We now go through all lines again and check if they're identical.
 846                 // If they're not, then that means it is a conflict, and we
 847                 // mark the conflict with the proper colors.
 848                 for (long i=0; i<m_Diff3.GetCount(); ++i)
 849                 {
 850                         DiffStates state1 = m_YourBaseBoth.GetState(i);
 851                         DiffStates state2 = m_TheirBaseBoth.GetState(i);
 852
 853                         if (((state1 == DIFFSTATE_IDENTICALADDED)||(state1 == DIFFSTATE_NORMAL))&&
 854                                 ((state2 == DIFFSTATE_IDENTICALADDED)||(state2 == DIFFSTATE_NORMAL)))
 855                         {
 856                                 LONG lineyour = m_arDiff3LinesYour.GetAt(i);
 857                                 LONG linetheir = m_arDiff3LinesTheir.GetAt(i);
 858                                 LONG linebase = m_arDiff3LinesBase.GetAt(i);
 859                                 if ((lineyour < m_arYourFile.GetCount()) &&
 860                                         (linetheir < m_arTheirFile.GetCount()) &&
 861                                         (linebase < m_arBaseFile.GetCount()))
 862                                 {
 863                                         if (((m_arYourFile.GetLineEnding(lineyour)!=m_arBaseFile.GetLineEnding(linebase))&&
 864                                                 (m_arTheirFile.GetLineEnding(linetheir)!=m_arBaseFile.GetLineEnding(linebase))&&
 865                                                 (m_arYourFile.GetLineEnding(lineyour)!=m_arTheirFile.GetLineEnding(linetheir))) ||
 866                                                 ((m_arYourFile.GetAt(lineyour).Compare(m_arBaseFile.GetAt(linebase))!=0)&&
 867                                                 (m_arTheirFile.GetAt(linetheir).Compare(m_arBaseFile.GetAt(linebase))!=0)&&
 868                                                 (m_arYourFile.GetAt(lineyour).Compare(m_arTheirFile.GetAt(linetheir))!=0)))
 869                                         {
 870                                                 m_Diff3.SetState(i, DIFFSTATE_CONFLICTED_IGNORED);
 871                                                 m_YourBaseBoth.SetState(i, DIFFSTATE_CONFLICTADDED);
 872                                                 m_TheirBaseBoth.SetState(i, DIFFSTATE_CONFLICTADDED);
 873                                         }
 874                                 }
 875                         }
 876                 }
 877         }
 878         ASSERT(m_Diff3.GetCount() == m_YourBaseBoth.GetCount());
 879         ASSERT(m_TheirBaseBoth.GetCount() == m_YourBaseBoth.GetCount());
 880
 881         TRACE(_T("done with 3-way diff\n"));
 882         return true;
 883 }