?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Success build TortoiseMerge.
[TortoiseGit.git] / src / TortoiseMerge / Patch.cpp
blob79ea336f5547ef956543f39f49da72fae8c6673f
1 // TortoiseMerge - a Diff/Patch program
2
3 // Copyright (C) 2004-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 "Resource.h"
21 #include "UnicodeUtils.h"
22 #include "DirFileEnum.h"
23 #include "TortoiseMerge.h"
24 #include "svn_wc.h"
25 #include "GitAdminDir.h"
26 #include "Patch.h"
27
28 #ifdef _DEBUG
29 #define new DEBUG_NEW
30 #undef THIS_FILE
31 static char THIS_FILE[] = __FILE__;
32 #endif
33
34 CPatch::CPatch(void)
35 {
36 m_nStrip = 0;
37 }
38
39 CPatch::~CPatch(void)
40 {
41 FreeMemory();
42 }
43
44 void CPatch::FreeMemory()
45 {
46 for (int i=0; i<m_arFileDiffs.GetCount(); i++)
47 {
48 Chunks * chunks = m_arFileDiffs.GetAt(i);
49 for (int j=0; j<chunks->chunks.GetCount(); j++)
50 {
51 delete chunks->chunks.GetAt(j);
52 }
53 chunks->chunks.RemoveAll();
54 delete chunks;
55 }
56 m_arFileDiffs.RemoveAll();
57 }
58
59 BOOL CPatch::OpenUnifiedDiffFile(const CString& filename)
60 {
61 CString sLine;
62 EOL ending = EOL_NOENDING;
63 INT_PTR nIndex = 0;
64 INT_PTR nLineCount = 0;
65 g_crasher.AddFile((LPCSTR)(LPCTSTR)filename, (LPCSTR)(LPCTSTR)_T("unified diff file"));
66
67 CFileTextLines PatchLines;
68 if (!PatchLines.Load(filename))
69 {
70 m_sErrorMessage = PatchLines.GetErrorString();
71 return FALSE;
72 }
73 m_UnicodeType = PatchLines.GetUnicodeType();
74 FreeMemory();
75 nLineCount = PatchLines.GetCount();
76 //now we got all the lines of the patch file
77 //in our array - parsing can start...
78
79 //first, skip possible garbage at the beginning
80 //garbage is finished when a line starts with "Index: "
81 //and the next line consists of only "=" characters
82 for (; nIndex<PatchLines.GetCount(); nIndex++)
83 {
84 sLine = PatchLines.GetAt(nIndex);
85 if (sLine.Left(4).Compare(_T("--- "))==0)
86 break;
87 if ((nIndex+1)<PatchLines.GetCount())
88 {
89 sLine = PatchLines.GetAt(nIndex+1);
90 sLine.Replace(_T("="), _T(""));
91 if (sLine.IsEmpty())
92 break;
93 }
94 }
95 if ((PatchLines.GetCount()-nIndex) < 2)
96 {
97 //no file entry found.
98 m_sErrorMessage.LoadString(IDS_ERR_PATCH_NOINDEX);
99 return FALSE;
100 }
101
102 //from this point on we have the real unified diff data
103 int state = 0;
104 Chunks * chunks = NULL;
105 Chunk * chunk = NULL;
106 int nAddLineCount = 0;
107 int nRemoveLineCount = 0;
108 int nContextLineCount = 0;
109 for ( ;nIndex<PatchLines.GetCount(); nIndex++)
110 {
111 sLine = PatchLines.GetAt(nIndex);
112 ending = PatchLines.GetLineEnding(nIndex);
113 if (ending != EOL_NOENDING)
114 ending = EOL_AUTOLINE;
115 if (state == 0)
116 {
117 if ((sLine.Left(4).Compare(_T("--- "))==0)&&(sLine.Find('\t') >= 0))
118 {
119 state = 2;
120 if (chunks)
121 {
122 //this is a new file diff, so add the last one to
123 //our array.
124 m_arFileDiffs.Add(chunks);
125 }
126 chunks = new Chunks();
127 int nTab = sLine.Find('\t');
128 if (nTab >= 0)
129 {
130 chunks->sFilePath = sLine.Mid(4, nTab-4).Trim();
131 }
132 }
133 }
134 switch (state)
135 {
136 case 0: //Index: <filepath>
137 {
138 CString nextLine;
139 if ((nIndex+1)<PatchLines.GetCount())
140 {
141 nextLine = PatchLines.GetAt(nIndex+1);
142 if (!nextLine.IsEmpty())
143 {
144 nextLine.Replace(_T("="), _T(""));
145 if (nextLine.IsEmpty())
146 {
147 if (chunks)
148 {
149 //this is a new file diff, so add the last one to
150 //our array.
151 m_arFileDiffs.Add(chunks);
152 }
153 chunks = new Chunks();
154 int nColon = sLine.Find(':');
155 if (nColon >= 0)
156 {
157 chunks->sFilePath = sLine.Mid(nColon+1).Trim();
158 if (chunks->sFilePath.Find('\t')>=0)
159 chunks->sFilePath.Left(chunks->sFilePath.Find('\t')).TrimRight();
160 if (chunks->sFilePath.Right(9).Compare(_T("(deleted)"))==0)
161 chunks->sFilePath.Left(chunks->sFilePath.GetLength()-9).TrimRight();
162 if (chunks->sFilePath.Right(7).Compare(_T("(added)"))==0)
163 chunks->sFilePath.Left(chunks->sFilePath.GetLength()-7).TrimRight();
164 }
165 state++;
166 }
167 }
168 }
169 if (state == 0)
170 {
171 if (nIndex > 0)
172 {
173 nIndex--;
174 state = 4;
175 if (chunks == NULL)
176 {
177 //the line
178 //Index: <filepath>
179 //was not found at the start of a file diff!
180 break;
181 }
182 }
183 }
184 }
185 break;
186 case 1: //====================
187 {
188 sLine.Replace(_T("="), _T(""));
189 if (sLine.IsEmpty())
190 {
191 // if the next line is already the start of the chunk,
192 // then the patch/diff file was not created by svn. But we
193 // still try to use it
194 if (PatchLines.GetCount() > (nIndex + 1))
195 {
196
197 if (PatchLines.GetAt(nIndex+1).Left(2).Compare(_T("@@"))==0)
198 {
199 state += 2;
200 }
201 }
202 state++;
203 }
204 else
205 {
206 //the line
207 //=========================
208 //was not found
209 m_sErrorMessage.Format(IDS_ERR_PATCH_NOEQUATIONCHARLINE, nIndex);
210 goto errorcleanup;
211 }
212 }
213 break;
214 case 2: //--- <filepath>
215 {
216 if (sLine.Left(3).Compare(_T("---"))!=0)
217 {
218 //no starting "---" found
219 //seems to be either garbage or just
220 //a binary file. So start over...
221 state = 0;
222 nIndex--;
223 if (chunks)
224 {
225 delete chunks;
226 chunks = NULL;
227 }
228 break;
229 }
230 sLine = sLine.Mid(3); //remove the "---"
231 sLine =sLine.Trim();
232 //at the end of the filepath there's a revision number...
233 int bracket = sLine.ReverseFind('(');
234 if (bracket < 0)
235 // some patch files can have another '(' char, especially ones created in Chinese OS
236 bracket = sLine.ReverseFind(0xff08);
237 CString num = sLine.Mid(bracket); //num = "(revision xxxxx)"
238 num = num.Mid(num.Find(' '));
239 num = num.Trim(_T(" )"));
240 // here again, check for the Chinese bracket
241 num = num.Trim(0xff09);
242 chunks->sRevision = num;
243 if (bracket < 0)
244 {
245 if (chunks->sFilePath.IsEmpty())
246 chunks->sFilePath = sLine.Trim();
247 }
248 else
249 chunks->sFilePath = sLine.Left(bracket-1).Trim();
250 if (chunks->sFilePath.Find('\t')>=0)
251 {
252 chunks->sFilePath = chunks->sFilePath.Left(chunks->sFilePath.Find('\t'));
253 }
254 state++;
255 }
256 break;
257 case 3: //+++ <filepath>
258 {
259 if (sLine.Left(3).Compare(_T("+++"))!=0)
260 {
261 //no starting "+++" found
262 m_sErrorMessage.Format(IDS_ERR_PATCH_NOADDFILELINE, nIndex);
263 goto errorcleanup;
264 }
265 sLine = sLine.Mid(3); //remove the "---"
266 sLine =sLine.Trim();
267 //at the end of the filepath there's a revision number...
268 int bracket = sLine.ReverseFind('(');
269 if (bracket < 0)
270 // some patch files can have another '(' char, especially ones created in Chinese OS
271 bracket = sLine.ReverseFind(0xff08);
272 CString num = sLine.Mid(bracket); //num = "(revision xxxxx)"
273 num = num.Mid(num.Find(' '));
274 num = num.Trim(_T(" )"));
275 // here again, check for the Chinese bracket
276 num = num.Trim(0xff09);
277 chunks->sRevision2 = num;
278 if (bracket < 0)
279 chunks->sFilePath2 = sLine.Trim();
280 else
281 chunks->sFilePath2 = sLine.Left(bracket-1).Trim();
282 if (chunks->sFilePath2.Find('\t')>=0)
283 {
284 chunks->sFilePath2 = chunks->sFilePath2.Left(chunks->sFilePath2.Find('\t'));
285 }
286 state++;
287 }
288 break;
289 case 4: //@@ -xxx,xxx +xxx,xxx @@
290 {
291 //start of a new chunk
292 if (sLine.Left(2).Compare(_T("@@"))!=0)
293 {
294 //chunk doesn't start with "@@"
295 //so there's garbage in between two file diffs
296 state = 0;
297 if (chunk)
298 {
299 delete chunk;
300 chunk = 0;
301 if (chunks)
302 {
303 for (int i=0; i<chunks->chunks.GetCount(); i++)
304 {
305 delete chunks->chunks.GetAt(i);
306 }
307 chunks->chunks.RemoveAll();
308 delete chunks;
309 chunks = NULL;
310 }
311 }
312 break; //skip the garbage
313 }
314 sLine = sLine.Mid(2);
315 sLine = sLine.Trim();
316 chunk = new Chunk();
317 CString sRemove = sLine.Left(sLine.Find(' '));
318 CString sAdd = sLine.Mid(sLine.Find(' '));
319 chunk->lRemoveStart = (-_ttol(sRemove));
320 if (sRemove.Find(',')>=0)
321 {
322 sRemove = sRemove.Mid(sRemove.Find(',')+1);
323 chunk->lRemoveLength = _ttol(sRemove);
324 }
325 else
326 {
327 chunk->lRemoveStart = 0;
328 chunk->lRemoveLength = (-_ttol(sRemove));
329 }
330 chunk->lAddStart = _ttol(sAdd);
331 if (sAdd.Find(',')>=0)
332 {
333 sAdd = sAdd.Mid(sAdd.Find(',')+1);
334 chunk->lAddLength = _ttol(sAdd);
335 }
336 else
337 {
338 chunk->lAddStart = 1;
339 chunk->lAddLength = _ttol(sAdd);
340 }
341 state++;
342 }
343 break;
344 case 5: //[ |+|-] <sourceline>
345 {
346 //this line is either a context line (with a ' ' in front)
347 //a line added (with a '+' in front)
348 //or a removed line (with a '-' in front)
349 TCHAR type;
350 if (sLine.IsEmpty())
351 type = ' ';
352 else
353 type = sLine.GetAt(0);
354 if (type == ' ')
355 {
356 //it's a context line - we don't use them here right now
357 //but maybe in the future the patch algorithm can be
358 //extended to use those in case the file to patch has
359 //already changed and no base file is around...
360 chunk->arLines.Add(RemoveUnicodeBOM(sLine.Mid(1)));
361 chunk->arLinesStates.Add(PATCHSTATE_CONTEXT);
362 chunk->arEOLs.push_back(ending);
363 nContextLineCount++;
364 }
365 else if (type == '\\')
366 {
367 //it's a context line (sort of):
368 //warnings start with a '\' char (e.g. "\ No newline at end of file")
369 //so just ignore this...
370 }
371 else if (type == '-')
372 {
373 //a removed line
374 chunk->arLines.Add(RemoveUnicodeBOM(sLine.Mid(1)));
375 chunk->arLinesStates.Add(PATCHSTATE_REMOVED);
376 chunk->arEOLs.push_back(ending);
377 nRemoveLineCount++;
378 }
379 else if (type == '+')
380 {
381 //an added line
382 chunk->arLines.Add(RemoveUnicodeBOM(sLine.Mid(1)));
383 chunk->arLinesStates.Add(PATCHSTATE_ADDED);
384 chunk->arEOLs.push_back(ending);
385 nAddLineCount++;
386 }
387 else
388 {
389 //none of those lines! what the hell happened here?
390 m_sErrorMessage.Format(IDS_ERR_PATCH_UNKOWNLINETYPE, nIndex);
391 goto errorcleanup;
392 }
393 if ((chunk->lAddLength == (nAddLineCount + nContextLineCount)) &&
394 chunk->lRemoveLength == (nRemoveLineCount + nContextLineCount))
395 {
396 //chunk is finished
397 if (chunks)
398 chunks->chunks.Add(chunk);
399 else
400 delete chunk;
401 chunk = NULL;
402 nAddLineCount = 0;
403 nContextLineCount = 0;
404 nRemoveLineCount = 0;
405 state = 0;
406 }
407 }
408 break;
409 default:
410 ASSERT(FALSE);
411 } // switch (state)
412 } // for ( ;nIndex<m_PatchLines.GetCount(); nIndex++)
413 if (chunk)
414 {
415 m_sErrorMessage.LoadString(IDS_ERR_PATCH_CHUNKMISMATCH);
416 goto errorcleanup;
417 }
418 if (chunks)
419 m_arFileDiffs.Add(chunks);
420 return TRUE;
421 errorcleanup:
422 if (chunk)
423 delete chunk;
424 if (chunks)
425 {
426 for (int i=0; i<chunks->chunks.GetCount(); i++)
427 {
428 delete chunks->chunks.GetAt(i);
429 }
430 chunks->chunks.RemoveAll();
431 delete chunks;
432 }
433 FreeMemory();
434 return FALSE;
435 }
436
437 CString CPatch::GetFilename(int nIndex)
438 {
439 if (nIndex < 0)
440 return _T("");
441 if (nIndex < m_arFileDiffs.GetCount())
442 {
443 Chunks * c = m_arFileDiffs.GetAt(nIndex);
444 CString filepath = Strip(c->sFilePath);
445 return filepath;
446 }
447 return _T("");
448 }
449
450 CString CPatch::GetRevision(int nIndex)
451 {
452 if (nIndex < 0)
453 return 0;
454 if (nIndex < m_arFileDiffs.GetCount())
455 {
456 Chunks * c = m_arFileDiffs.GetAt(nIndex);
457 return c->sRevision;
458 }
459 return 0;
460 }
461
462 CString CPatch::GetFilename2(int nIndex)
463 {
464 if (nIndex < 0)
465 return _T("");
466 if (nIndex < m_arFileDiffs.GetCount())
467 {
468 Chunks * c = m_arFileDiffs.GetAt(nIndex);
469 CString filepath = Strip(c->sFilePath2);
470 return filepath;
471 }
472 return _T("");
473 }
474
475 CString CPatch::GetRevision2(int nIndex)
476 {
477 if (nIndex < 0)
478 return 0;
479 if (nIndex < m_arFileDiffs.GetCount())
480 {
481 Chunks * c = m_arFileDiffs.GetAt(nIndex);
482 return c->sRevision2;
483 }
484 return 0;
485 }
486
487 BOOL CPatch::PatchFile(const CString& sPath, const CString& sSavePath, const CString& sBaseFile)
488 {
489 if (PathIsDirectory(sPath))
490 {
491 m_sErrorMessage.Format(IDS_ERR_PATCH_INVALIDPATCHFILE, (LPCTSTR)sPath);
492 return FALSE;
493 }
494 // find the entry in the patch file which matches the full path given in sPath.
495 int nIndex = -1;
496 // use the longest path that matches
497 int nMaxMatch = 0;
498 for (int i=0; i<GetNumberOfFiles(); i++)
499 {
500 CString temppath = sPath;
501 CString temp = GetFilename(i);
502 temppath.Replace('/', '\\');
503 temp.Replace('/', '\\');
504 if (temppath.Mid(temppath.GetLength()-temp.GetLength()-1, 1).CompareNoCase(_T("\\"))==0)
505 {
506 temppath = temppath.Right(temp.GetLength());
507 if ((temp.CompareNoCase(temppath)==0))
508 {
509 if (nMaxMatch < temp.GetLength())
510 {
511 nMaxMatch = temp.GetLength();
512 nIndex = i;
513 }
514 }
515 }
516 else if (temppath.CompareNoCase(temp)==0)
517 {
518 if ((nIndex < 0)&&(! temp.IsEmpty()))
519 {
520 nIndex = i;
521 }
522 }
523 }
524 if (nIndex < 0)
525 {
526 m_sErrorMessage.Format(IDS_ERR_PATCH_FILENOTINPATCH, (LPCTSTR)sPath);
527 return FALSE;
528 }
529
530 CString sLine;
531 CString sPatchFile = sBaseFile.IsEmpty() ? sPath : sBaseFile;
532 if (PathFileExists(sPatchFile))
533 {
534 g_crasher.AddFile((LPCSTR)(LPCTSTR)sPatchFile, (LPCSTR)(LPCTSTR)_T("File to patch"));
535 }
536 CFileTextLines PatchLines;
537 CFileTextLines PatchLinesResult;
538 PatchLines.Load(sPatchFile);
539 PatchLinesResult = PatchLines; //.Copy(PatchLines);
540 PatchLines.CopySettings(&PatchLinesResult);
541
542 Chunks * chunks = m_arFileDiffs.GetAt(nIndex);
543
544 for (int i=0; i<chunks->chunks.GetCount(); i++)
545 {
546 Chunk * chunk = chunks->chunks.GetAt(i);
547 LONG lRemoveLine = chunk->lRemoveStart;
548 LONG lAddLine = chunk->lAddStart;
549 for (int j=0; j<chunk->arLines.GetCount(); j++)
550 {
551 CString sPatchLine = chunk->arLines.GetAt(j);
552 EOL ending = chunk->arEOLs[j];
553 if ((m_UnicodeType != CFileTextLines::UTF8)&&(m_UnicodeType != CFileTextLines::UTF8BOM))
554 {
555 if ((PatchLines.GetUnicodeType()==CFileTextLines::UTF8)||(m_UnicodeType == CFileTextLines::UTF8BOM))
556 {
557 // convert the UTF-8 contents in CString sPatchLine into a CStringA
558 sPatchLine = CUnicodeUtils::GetUnicode(CStringA(sPatchLine));
559 }
560 }
561 int nPatchState = (int)chunk->arLinesStates.GetAt(j);
562 switch (nPatchState)
563 {
564 case PATCHSTATE_REMOVED:
565 {
566 if ((lAddLine > PatchLines.GetCount())||(PatchLines.GetCount()==0))
567 {
568 m_sErrorMessage.Format(IDS_ERR_PATCH_DOESNOTMATCH, _T(""), (LPCTSTR)sPatchLine);
569 return FALSE;
570 }
571 if (lAddLine == 0)
572 lAddLine = 1;
573 if ((sPatchLine.Compare(PatchLines.GetAt(lAddLine-1))!=0)&&(!HasExpandedKeyWords(sPatchLine)))
574 {
575 m_sErrorMessage.Format(IDS_ERR_PATCH_DOESNOTMATCH, (LPCTSTR)sPatchLine, (LPCTSTR)PatchLines.GetAt(lAddLine-1));
576 return FALSE;
577 }
578 if (lAddLine > PatchLines.GetCount())
579 {
580 m_sErrorMessage.Format(IDS_ERR_PATCH_DOESNOTMATCH, (LPCTSTR)sPatchLine, _T(""));
581 return FALSE;
582 }
583 PatchLines.RemoveAt(lAddLine-1);
584 }
585 break;
586 case PATCHSTATE_ADDED:
587 {
588 if (lAddLine == 0)
589 lAddLine = 1;
590 PatchLines.InsertAt(lAddLine-1, sPatchLine, ending);
591 lAddLine++;
592 }
593 break;
594 case PATCHSTATE_CONTEXT:
595 {
596 if (lAddLine > PatchLines.GetCount())
597 {
598 m_sErrorMessage.Format(IDS_ERR_PATCH_DOESNOTMATCH, _T(""), (LPCTSTR)sPatchLine);
599 return FALSE;
600 }
601 if (lAddLine == 0)
602 lAddLine++;
603 if (lRemoveLine == 0)
604 lRemoveLine++;
605 if ((sPatchLine.Compare(PatchLines.GetAt(lAddLine-1))!=0) &&
606 (!HasExpandedKeyWords(sPatchLine)) &&
607 (lRemoveLine <= PatchLines.GetCount()) &&
608 (sPatchLine.Compare(PatchLines.GetAt(lRemoveLine-1))!=0))
609 {
610 if ((lAddLine < PatchLines.GetCount())&&(sPatchLine.Compare(PatchLines.GetAt(lAddLine))==0))
611 lAddLine++;
612 else if (((lAddLine + 1) < PatchLines.GetCount())&&(sPatchLine.Compare(PatchLines.GetAt(lAddLine+1))==0))
613 lAddLine += 2;
614 else if ((lRemoveLine < PatchLines.GetCount())&&(sPatchLine.Compare(PatchLines.GetAt(lRemoveLine))==0))
615 lRemoveLine++;
616 else
617 {
618 m_sErrorMessage.Format(IDS_ERR_PATCH_DOESNOTMATCH, (LPCTSTR)sPatchLine, (LPCTSTR)PatchLines.GetAt(lAddLine-1));
619 return FALSE;
620 }
621 }
622 lAddLine++;
623 lRemoveLine++;
624 }
625 break;
626 default:
627 ASSERT(FALSE);
628 break;
629 } // switch (nPatchState)
630 } // for (j=0; j<chunk->arLines.GetCount(); j++)
631 } // for (int i=0; i<chunks->chunks.GetCount(); i++)
632 if (!sSavePath.IsEmpty())
633 {
634 PatchLines.Save(sSavePath, false);
635 }
636 return TRUE;
637 }
638
639 BOOL CPatch::HasExpandedKeyWords(const CString& line)
640 {
641 if (line.Find(_T("$LastChangedDate"))>=0)
642 return TRUE;
643 if (line.Find(_T("$Date"))>=0)
644 return TRUE;
645 if (line.Find(_T("$LastChangedRevision"))>=0)
646 return TRUE;
647 if (line.Find(_T("$Rev"))>=0)
648 return TRUE;
649 if (line.Find(_T("$LastChangedBy"))>=0)
650 return TRUE;
651 if (line.Find(_T("$Author"))>=0)
652 return TRUE;
653 if (line.Find(_T("$HeadURL"))>=0)
654 return TRUE;
655 if (line.Find(_T("$URL"))>=0)
656 return TRUE;
657 if (line.Find(_T("$Id"))>=0)
658 return TRUE;
659 return FALSE;
660 }
661
662 CString CPatch::CheckPatchPath(const CString& path)
663 {
664 //first check if the path already matches
665 if (CountMatches(path) > (GetNumberOfFiles()/3))
666 return path;
667 //now go up the tree and try again
668 CString upperpath = path;
669 while (upperpath.ReverseFind('\\')>0)
670 {
671 upperpath = upperpath.Left(upperpath.ReverseFind('\\'));
672 if (CountMatches(upperpath) > (GetNumberOfFiles()/3))
673 return upperpath;
674 }
675 //still no match found. So try sub folders
676 bool isDir = false;
677 CString subpath;
678 CDirFileEnum filefinder(path);
679 while (filefinder.NextFile(subpath, &isDir))
680 {
681 if (!isDir)
682 continue;
683 if (g_GitAdminDir.IsAdminDirPath(subpath))
684 continue;
685 if (CountMatches(subpath) > (GetNumberOfFiles()/3))
686 return subpath;
687 }
688
689 // if a patch file only contains newly added files
690 // we can't really find the correct path.
691 // But: we can compare paths strings without the filenames
692 // and check if at least those match
693 upperpath = path;
694 while (upperpath.ReverseFind('\\')>0)
695 {
696 upperpath = upperpath.Left(upperpath.ReverseFind('\\'));
697 if (CountDirMatches(upperpath) > (GetNumberOfFiles()/3))
698 return upperpath;
699 }
700
701 return path;
702 }
703
704 int CPatch::CountMatches(const CString& path)
705 {
706 int matches = 0;
707 for (int i=0; i<GetNumberOfFiles(); ++i)
708 {
709 CString temp = GetFilename(i);
710 temp.Replace('/', '\\');
711 if (PathIsRelative(temp))
712 temp = path + _T("\\")+ temp;
713 if (PathFileExists(temp))
714 matches++;
715 }
716 return matches;
717 }
718
719 int CPatch::CountDirMatches(const CString& path)
720 {
721 int matches = 0;
722 for (int i=0; i<GetNumberOfFiles(); ++i)
723 {
724 CString temp = GetFilename(i);
725 temp.Replace('/', '\\');
726 if (PathIsRelative(temp))
727 temp = path + _T("\\")+ temp;
728 // remove the filename
729 temp = temp.Left(temp.ReverseFind('\\'));
730 if (PathFileExists(temp))
731 matches++;
732 }
733 return matches;
734 }
735
736 BOOL CPatch::StripPrefixes(const CString& path)
737 {
738 int nSlashesMax = 0;
739 for (int i=0; i<GetNumberOfFiles(); i++)
740 {
741 CString filename = GetFilename(i);
742 filename.Replace('/','\\');
743 int nSlashes = filename.Replace('\\','/');
744 nSlashesMax = max(nSlashesMax,nSlashes);
745 }
746
747 for (int nStrip=1;nStrip<nSlashesMax;nStrip++)
748 {
749 m_nStrip = nStrip;
750 if ( CountMatches(path) > GetNumberOfFiles()/3 )
751 {
752 // Use current m_nStrip
753 return TRUE;
754 }
755 }
756
757 // Stripping doesn't help so reset it again
758 m_nStrip = 0;
759 return FALSE;
760 }
761
762 CString CPatch::Strip(const CString& filename)
763 {
764 CString s = filename;
765 if ( m_nStrip>0 )
766 {
767 // Remove windows drive letter "c:"
768 if ( s.GetLength()>2 && s[1]==':')
769 {
770 s = s.Mid(2);
771 }
772
773 for (int nStrip=1;nStrip<=m_nStrip;nStrip++)
774 {
775 // "/home/ts/my-working-copy/dir/file.txt"
776 // "home/ts/my-working-copy/dir/file.txt"
777 // "ts/my-working-copy/dir/file.txt"
778 // "my-working-copy/dir/file.txt"
779 // "dir/file.txt"
780 s = s.Mid(s.FindOneOf(_T("/\\"))+1);
781 }
782 }
783 return s;
784 }
785
786 CString CPatch::RemoveUnicodeBOM(const CString& str)
787 {
788 if (str.GetLength()==0)
789 return str;
790 if (str[0] == 0xFEFF)
791 return str.Mid(1);
792 return str;
793 }
Windows Explorer Extension to Operate Git