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