?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
optimize TGitCache for CLI operations
[TortoiseGit.git] / src / TortoiseMerge / Patch.cpp
blobbb0b8918c37bc4f262afcf0c3cb73bd48a97c76c
1 // TortoiseMerge - a Diff/Patch program
2
3 // Copyright (C) 2009-2011 - TortoiseGit
4 // Copyright (C) 2004-2009,2011 - TortoiseSVN
5
6 // This program is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU General Public License
8 // as published by the Free Software Foundation; either version 2
9 // of the License, or (at your option) any later version.
10
11 // This program is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15
16 // You should have received a copy of the GNU General Public License
17 // along with this program; if not, write to the Free Software Foundation,
18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 //
20 #include "StdAfx.h"
21 #include "Resource.h"
22 #include "UnicodeUtils.h"
23 #include "DirFileEnum.h"
24 #include "TortoiseMerge.h"
25 #include "svn_wc.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 , m_IsGitPatch(false)
39 {
40 }
41
42 CPatch::~CPatch(void)
43 {
44 FreeMemory();
45 }
46
47 void CPatch::FreeMemory()
48 {
49 for (int i=0; i<m_arFileDiffs.GetCount(); i++)
50 {
51 Chunks * chunks = m_arFileDiffs.GetAt(i);
52 for (int j=0; j<chunks->chunks.GetCount(); j++)
53 {
54 delete chunks->chunks.GetAt(j);
55 }
56 chunks->chunks.RemoveAll();
57 delete chunks;
58 }
59 m_arFileDiffs.RemoveAll();
60 }
61
62 BOOL CPatch::ParserGitPatch(CFileTextLines &PatchLines,int nIndex)
63 {
64 CString sLine;
65 EOL ending = EOL_NOENDING;
66
67 int state = 0;
68 Chunks * chunks = NULL;
69 Chunk * chunk = NULL;
70 int nAddLineCount = 0;
71 int nRemoveLineCount = 0;
72 int nContextLineCount = 0;
73 for ( ;nIndex<PatchLines.GetCount(); nIndex++)
74 {
75 sLine = PatchLines.GetAt(nIndex);
76 ending = PatchLines.GetLineEnding(nIndex);
77 if (ending != EOL_NOENDING)
78 ending = EOL_AUTOLINE;
79
80 switch (state)
81 {
82 case 0:
83 {
84 // diff --git
85 if( sLine.Find(_T("diff --git"))==0)
86 {
87 if (chunks)
88 {
89 //this is a new file diff, so add the last one to
90 //our array.
91 m_arFileDiffs.Add(chunks);
92 }
93 chunks = new Chunks();
94
95 }
96
97 //index
98 if( sLine.Find(_T("index"))==0 )
99 {
100 int dotstart=sLine.Find(_T(".."));
101 if(dotstart>=0)
102 {
103 chunks->sRevision = sLine.Mid(dotstart-7,7);
104 chunks->sRevision2 = sLine.Mid(dotstart+2,7);
105 }
106 }
107
108 //---
109 if( sLine.Find(_T("--- "))==0 )
110 {
111 if (sLine.Left(3).Compare(_T("---"))!=0)
112 {
113 //no starting "---" found
114 //seems to be either garbage or just
115 //a binary file. So start over...
116 state = 0;
117 nIndex--;
118 if (chunks)
119 {
120 delete chunks;
121 chunks = NULL;
122 }
123 break;
124 }
125
126 sLine = sLine.Mid(3); //remove the "---"
127 sLine =sLine.Trim();
128 //at the end of the filepath there's a revision number...
129 int bracket = sLine.ReverseFind('(');
130 if (bracket < 0)
131 // some patch files can have another '(' char, especially ones created in Chinese OS
132 bracket = sLine.ReverseFind(0xff08);
133
134 if (bracket < 0)
135 {
136 if (chunks->sFilePath.IsEmpty())
137 chunks->sFilePath = sLine.Trim();
138 }
139 else
140 chunks->sFilePath = sLine.Left(bracket-1).Trim();
141
142 if (chunks->sFilePath.Find('\t')>=0)
143 {
144 chunks->sFilePath = chunks->sFilePath.Left(chunks->sFilePath.Find('\t'));
145 }
146 if (chunks->sFilePath.Find(_T('"')) == 0 && chunks->sFilePath.ReverseFind(_T('"')) == chunks->sFilePath.GetLength() - 1)
147 chunks->sFilePath=chunks->sFilePath.Mid(1, chunks->sFilePath.GetLength() - 2);
148 if( chunks->sFilePath.Find(_T("a/")) == 0 )
149 chunks->sFilePath=chunks->sFilePath.Mid(2);
150
151 if( chunks->sFilePath.Find(_T("b/")) == 0 )
152 chunks->sFilePath=chunks->sFilePath.Mid(2);
153
154
155 chunks->sFilePath.Replace(_T('/'),_T('\\'));
156
157 if(chunks->sFilePath == _T("\\dev\\null"))
158 chunks->sFilePath = _T("NUL");
159 }
160
161 // +++
162 if( sLine.Find(_T("+++ ")) == 0 )
163 {
164 sLine = sLine.Mid(3); //remove the "---"
165 sLine =sLine.Trim();
166
167 //at the end of the filepath there's a revision number...
168 int bracket = sLine.ReverseFind('(');
169 if (bracket < 0)
170 // some patch files can have another '(' char, especially ones created in Chinese OS
171 bracket = sLine.ReverseFind(0xff08);
172
173 if (bracket < 0)
174 chunks->sFilePath2 = sLine.Trim();
175 else
176 chunks->sFilePath2 = sLine.Left(bracket-1).Trim();
177 if (chunks->sFilePath2.Find('\t')>=0)
178 {
179 chunks->sFilePath2 = chunks->sFilePath2.Left(chunks->sFilePath2.Find('\t'));
180 }
181 if (chunks->sFilePath2.Find(_T('"')) == 0 && chunks->sFilePath2.ReverseFind(_T('"')) == chunks->sFilePath2.GetLength() - 1)
182 chunks->sFilePath2=chunks->sFilePath2.Mid(1, chunks->sFilePath2.GetLength() - 2);
183 if( chunks->sFilePath2.Find(_T("a/")) == 0 )
184 chunks->sFilePath2=chunks->sFilePath2.Mid(2);
185
186 if( chunks->sFilePath2.Find(_T("b/")) == 0 )
187 chunks->sFilePath2=chunks->sFilePath2.Mid(2);
188
189 chunks->sFilePath2.Replace(_T('/'),_T('\\'));
190
191 if(chunks->sFilePath2 == _T("\\dev\\null"))
192 chunks->sFilePath2 = _T("NUL");
193 }
194
195 //@@ -xxx,xxx +xxx,xxx @@
196 if( sLine.Find(_T("@@")) == 0 )
197 {
198 sLine = sLine.Mid(2);
199 sLine = sLine.Trim();
200 chunk = new Chunk();
201 CString sRemove = sLine.Left(sLine.Find(' '));
202 CString sAdd = sLine.Mid(sLine.Find(' '));
203 chunk->lRemoveStart = (-_ttol(sRemove));
204 if (sRemove.Find(',')>=0)
205 {
206 sRemove = sRemove.Mid(sRemove.Find(',')+1);
207 chunk->lRemoveLength = _ttol(sRemove);
208 }
209 else
210 {
211 chunk->lRemoveStart = 0;
212 chunk->lRemoveLength = (-_ttol(sRemove));
213 }
214 chunk->lAddStart = _ttol(sAdd);
215 if (sAdd.Find(',')>=0)
216 {
217 sAdd = sAdd.Mid(sAdd.Find(',')+1);
218 chunk->lAddLength = _ttol(sAdd);
219 }
220 else
221 {
222 chunk->lAddStart = 1;
223 chunk->lAddLength = _ttol(sAdd);
224 }
225
226 state =5;
227 }
228 }
229 break;
230
231
232 case 5: //[ |+|-] <sourceline>
233 {
234 //this line is either a context line (with a ' ' in front)
235 //a line added (with a '+' in front)
236 //or a removed line (with a '-' in front)
237 TCHAR type;
238 if (sLine.IsEmpty())
239 type = ' ';
240 else
241 type = sLine.GetAt(0);
242 if (type == ' ')
243 {
244 //it's a context line - we don't use them here right now
245 //but maybe in the future the patch algorithm can be
246 //extended to use those in case the file to patch has
247 //already changed and no base file is around...
248 chunk->arLines.Add(RemoveUnicodeBOM(sLine.Mid(1)));
249 chunk->arLinesStates.Add(PATCHSTATE_CONTEXT);
250 chunk->arEOLs.push_back(ending);
251 nContextLineCount++;
252 }
253 else if (type == '\\')
254 {
255 //it's a context line (sort of):
256 //warnings start with a '\' char (e.g. "\ No newline at end of file")
257 //so just ignore this...
258 }
259 else if (type == '-')
260 {
261 //a removed line
262 chunk->arLines.Add(RemoveUnicodeBOM(sLine.Mid(1)));
263 chunk->arLinesStates.Add(PATCHSTATE_REMOVED);
264 chunk->arEOLs.push_back(ending);
265 nRemoveLineCount++;
266 }
267 else if (type == '+')
268 {
269 //an added line
270 chunk->arLines.Add(RemoveUnicodeBOM(sLine.Mid(1)));
271 chunk->arLinesStates.Add(PATCHSTATE_ADDED);
272 chunk->arEOLs.push_back(ending);
273 nAddLineCount++;
274 }
275 else
276 {
277 //none of those lines! what the hell happened here?
278 m_sErrorMessage.Format(IDS_ERR_PATCH_UNKOWNLINETYPE, nIndex);
279 goto errorcleanup;
280 }
281 if ((chunk->lAddLength == (nAddLineCount + nContextLineCount)) &&
282 chunk->lRemoveLength == (nRemoveLineCount + nContextLineCount))
283 {
284 //chunk is finished
285 if (chunks)
286 chunks->chunks.Add(chunk);
287 else
288 delete chunk;
289 chunk = NULL;
290 nAddLineCount = 0;
291 nContextLineCount = 0;
292 nRemoveLineCount = 0;
293 state = 0;
294 }
295 }
296 break;
297 default:
298 ASSERT(FALSE);
299 } // switch (state)
300 } // for ( ;nIndex<m_PatchLines.GetCount(); nIndex++)
301 if (chunk)
302 {
303 m_sErrorMessage.LoadString(IDS_ERR_PATCH_CHUNKMISMATCH);
304 goto errorcleanup;
305 }
306 if (chunks)
307 m_arFileDiffs.Add(chunks);
308 return TRUE;
309
310 errorcleanup:
311 if (chunk)
312 delete chunk;
313 if (chunks)
314 {
315 for (int i=0; i<chunks->chunks.GetCount(); i++)
316 {
317 delete chunks->chunks.GetAt(i);
318 }
319 chunks->chunks.RemoveAll();
320 delete chunks;
321 }
322 FreeMemory();
323 return FALSE;
324 }
325
326 BOOL CPatch::OpenUnifiedDiffFile(const CString& filename)
327 {
328 CString sLine;
329 EOL ending = EOL_NOENDING;
330 INT_PTR nIndex = 0;
331 INT_PTR nLineCount = 0;
332 g_crasher.AddFile((LPCSTR)(LPCTSTR)filename, (LPCSTR)(LPCTSTR)_T("unified diff file"));
333
334 CFileTextLines PatchLines;
335 if (!PatchLines.Load(filename))
336 {
337 m_sErrorMessage = PatchLines.GetErrorString();
338 return FALSE;
339 }
340 m_UnicodeType = PatchLines.GetUnicodeType();
341 FreeMemory();
342 nLineCount = PatchLines.GetCount();
343 //now we got all the lines of the patch file
344 //in our array - parsing can start...
345
346 for(nIndex=0;nIndex<PatchLines.GetCount();nIndex++)
347 {
348 sLine = PatchLines.GetAt(nIndex);
349 if(sLine.Left(10).Compare(_T("diff --git")) == 0)
350 {
351 this->m_IsGitPatch=true;
352 break;
353 }
354 }
355
356 //first, skip possible garbage at the beginning
357 //garbage is finished when a line starts with "Index: "
358 //and the next line consists of only "=" characters
359 if( !m_IsGitPatch )
360 {
361 for (nIndex=0; nIndex<PatchLines.GetCount(); nIndex++)
362 {
363 sLine = PatchLines.GetAt(nIndex);
364
365 if (sLine.Left(4).Compare(_T("--- "))==0)
366 break;
367 if ((nIndex+1)<PatchLines.GetCount())
368 {
369 sLine = PatchLines.GetAt(nIndex+1);
370
371 if(sLine.IsEmpty()&&m_IsGitPatch)
372 continue;
373
374 sLine.Remove('=');
375 if (sLine.IsEmpty())
376 break;
377 }
378 }
379 }
380
381 if ((PatchLines.GetCount()-nIndex) < 2)
382 {
383 //no file entry found.
384 m_sErrorMessage.LoadString(IDS_ERR_PATCH_NOINDEX);
385 return FALSE;
386 }
387
388 if( m_IsGitPatch )
389 return ParserGitPatch(PatchLines,nIndex);
390
391 //from this point on we have the real unified diff data
392 int state = 0;
393 Chunks * chunks = NULL;
394 Chunk * chunk = NULL;
395 int nAddLineCount = 0;
396 int nRemoveLineCount = 0;
397 int nContextLineCount = 0;
398 for ( ;nIndex<PatchLines.GetCount(); nIndex++)
399 {
400 sLine = PatchLines.GetAt(nIndex);
401 ending = PatchLines.GetLineEnding(nIndex);
402 if (ending != EOL_NOENDING)
403 ending = EOL_AUTOLINE;
404 if (state == 0)
405 {
406 if ((sLine.Left(4).Compare(_T("--- "))==0)&&((sLine.Find('\t') >= 0)||this->m_IsGitPatch))
407 {
408 state = 2;
409 if (chunks)
410 {
411 //this is a new file diff, so add the last one to
412 //our array.
413 m_arFileDiffs.Add(chunks);
414 }
415 chunks = new Chunks();
416
417 int nTab = sLine.Find('\t');
418
419 int filestart = 4;
420 if(m_IsGitPatch)
421 {
422 nTab=sLine.GetLength();
423 filestart = 6;
424 }
425
426 if (nTab >= 0)
427 {
428 chunks->sFilePath = sLine.Mid(filestart, nTab-filestart).Trim();
429 }
430 }
431 }
432 switch (state)
433 {
434 case 0: //Index: <filepath>
435 {
436 CString nextLine;
437 if ((nIndex+1)<PatchLines.GetCount())
438 {
439 nextLine = PatchLines.GetAt(nIndex+1);
440 if (!nextLine.IsEmpty())
441 {
442 nextLine.Remove('=');
443 if (nextLine.IsEmpty())
444 {
445 if (chunks)
446 {
447 //this is a new file diff, so add the last one to
448 //our array.
449 m_arFileDiffs.Add(chunks);
450 }
451 chunks = new Chunks();
452 int nColon = sLine.Find(':');
453 if (nColon >= 0)
454 {
455 chunks->sFilePath = sLine.Mid(nColon+1).Trim();
456 if (chunks->sFilePath.Find('\t')>=0)
457 chunks->sFilePath.Left(chunks->sFilePath.Find('\t')).TrimRight();
458 if (chunks->sFilePath.Right(9).Compare(_T("(deleted)"))==0)
459 chunks->sFilePath.Left(chunks->sFilePath.GetLength()-9).TrimRight();
460 if (chunks->sFilePath.Right(7).Compare(_T("(added)"))==0)
461 chunks->sFilePath.Left(chunks->sFilePath.GetLength()-7).TrimRight();
462 }
463 state++;
464 }
465 }
466 }
467 if (state == 0)
468 {
469 if (nIndex > 0)
470 {
471 nIndex--;
472 state = 4;
473 if (chunks == NULL)
474 {
475 //the line
476 //Index: <filepath>
477 //was not found at the start of a file diff!
478 break;
479 }
480 }
481 }
482 }
483 break;
484 case 1: //====================
485 {
486 sLine.Remove('=');
487 if (sLine.IsEmpty())
488 {
489 // if the next line is already the start of the chunk,
490 // then the patch/diff file was not created by svn. But we
491 // still try to use it
492 if (PatchLines.GetCount() > (nIndex + 1))
493 {
494
495 if (PatchLines.GetAt(nIndex+1).Left(2).Compare(_T("@@"))==0)
496 {
497 state += 2;
498 }
499 }
500 state++;
501 }
502 else
503 {
504 //the line
505 //=========================
506 //was not found
507 m_sErrorMessage.Format(IDS_ERR_PATCH_NOEQUATIONCHARLINE, nIndex);
508 goto errorcleanup;
509 }
510 }
511 break;
512 case 2: //--- <filepath>
513 {
514 if (sLine.Left(3).Compare(_T("---"))!=0)
515 {
516 //no starting "---" found
517 //seems to be either garbage or just
518 //a binary file. So start over...
519 state = 0;
520 nIndex--;
521 if (chunks)
522 {
523 delete chunks;
524 chunks = NULL;
525 }
526 break;
527 }
528 sLine = sLine.Mid(3); //remove the "---"
529 sLine =sLine.Trim();
530 //at the end of the filepath there's a revision number...
531 int bracket = sLine.ReverseFind('(');
532 if (bracket < 0)
533 // some patch files can have another '(' char, especially ones created in Chinese OS
534 bracket = sLine.ReverseFind(0xff08);
535 CString num = sLine.Mid(bracket); //num = "(revision xxxxx)"
536 num = num.Mid(num.Find(' '));
537 num = num.Trim(_T(" )"));
538 // here again, check for the Chinese bracket
539 num = num.Trim(0xff09);
540 chunks->sRevision = num;
541 if (bracket < 0)
542 {
543 if (chunks->sFilePath.IsEmpty())
544 chunks->sFilePath = sLine.Trim();
545 }
546 else
547 chunks->sFilePath = sLine.Left(bracket-1).Trim();
548 if (chunks->sFilePath.Find('\t')>=0)
549 {
550 chunks->sFilePath = chunks->sFilePath.Left(chunks->sFilePath.Find('\t'));
551 }
552 state++;
553 }
554 break;
555 case 3: //+++ <filepath>
556 {
557 if (sLine.Left(3).Compare(_T("+++"))!=0)
558 {
559 //no starting "+++" found
560 m_sErrorMessage.Format(IDS_ERR_PATCH_NOADDFILELINE, nIndex);
561 goto errorcleanup;
562 }
563 sLine = sLine.Mid(3); //remove the "---"
564 sLine =sLine.Trim();
565 //at the end of the filepath there's a revision number...
566 int bracket = sLine.ReverseFind('(');
567 if (bracket < 0)
568 // some patch files can have another '(' char, especially ones created in Chinese OS
569 bracket = sLine.ReverseFind(0xff08);
570 CString num = sLine.Mid(bracket); //num = "(revision xxxxx)"
571 num = num.Mid(num.Find(' '));
572 num = num.Trim(_T(" )"));
573 // here again, check for the Chinese bracket
574 num = num.Trim(0xff09);
575 chunks->sRevision2 = num;
576 if (bracket < 0)
577 chunks->sFilePath2 = sLine.Trim();
578 else
579 chunks->sFilePath2 = sLine.Left(bracket-1).Trim();
580 if (chunks->sFilePath2.Find('\t')>=0)
581 {
582 chunks->sFilePath2 = chunks->sFilePath2.Left(chunks->sFilePath2.Find('\t'));
583 }
584 state++;
585 }
586 break;
587 case 4: //@@ -xxx,xxx +xxx,xxx @@
588 {
589 //start of a new chunk
590 if (sLine.Left(2).Compare(_T("@@"))!=0)
591 {
592 //chunk doesn't start with "@@"
593 //so there's garbage in between two file diffs
594 state = 0;
595 if (chunk)
596 {
597 delete chunk;
598 chunk = 0;
599 if (chunks)
600 {
601 for (int i=0; i<chunks->chunks.GetCount(); i++)
602 {
603 delete chunks->chunks.GetAt(i);
604 }
605 chunks->chunks.RemoveAll();
606 delete chunks;
607 chunks = NULL;
608 }
609 }
610 break; //skip the garbage
611 }
612 sLine = sLine.Mid(2);
613 sLine = sLine.Trim();
614 chunk = new Chunk();
615 CString sRemove = sLine.Left(sLine.Find(' '));
616 CString sAdd = sLine.Mid(sLine.Find(' '));
617 chunk->lRemoveStart = (-_ttol(sRemove));
618 if (sRemove.Find(',')>=0)
619 {
620 sRemove = sRemove.Mid(sRemove.Find(',')+1);
621 chunk->lRemoveLength = _ttol(sRemove);
622 }
623 else
624 {
625 chunk->lRemoveStart = 0;
626 chunk->lRemoveLength = (-_ttol(sRemove));
627 }
628 chunk->lAddStart = _ttol(sAdd);
629 if (sAdd.Find(',')>=0)
630 {
631 sAdd = sAdd.Mid(sAdd.Find(',')+1);
632 chunk->lAddLength = _ttol(sAdd);
633 }
634 else
635 {
636 chunk->lAddStart = 1;
637 chunk->lAddLength = _ttol(sAdd);
638 }
639 state++;
640 }
641 break;
642 case 5: //[ |+|-] <sourceline>
643 {
644 //this line is either a context line (with a ' ' in front)
645 //a line added (with a '+' in front)
646 //or a removed line (with a '-' in front)
647 TCHAR type;
648 if (sLine.IsEmpty())
649 type = ' ';
650 else
651 type = sLine.GetAt(0);
652 if (type == ' ')
653 {
654 //it's a context line - we don't use them here right now
655 //but maybe in the future the patch algorithm can be
656 //extended to use those in case the file to patch has
657 //already changed and no base file is around...
658 chunk->arLines.Add(RemoveUnicodeBOM(sLine.Mid(1)));
659 chunk->arLinesStates.Add(PATCHSTATE_CONTEXT);
660 chunk->arEOLs.push_back(ending);
661 nContextLineCount++;
662 }
663 else if (type == '\\')
664 {
665 //it's a context line (sort of):
666 //warnings start with a '\' char (e.g. "\ No newline at end of file")
667 //so just ignore this...
668 }
669 else if (type == '-')
670 {
671 //a removed line
672 chunk->arLines.Add(RemoveUnicodeBOM(sLine.Mid(1)));
673 chunk->arLinesStates.Add(PATCHSTATE_REMOVED);
674 chunk->arEOLs.push_back(ending);
675 nRemoveLineCount++;
676 }
677 else if (type == '+')
678 {
679 //an added line
680 chunk->arLines.Add(RemoveUnicodeBOM(sLine.Mid(1)));
681 chunk->arLinesStates.Add(PATCHSTATE_ADDED);
682 chunk->arEOLs.push_back(ending);
683 nAddLineCount++;
684 }
685 else
686 {
687 //none of those lines! what the hell happened here?
688 m_sErrorMessage.Format(IDS_ERR_PATCH_UNKOWNLINETYPE, nIndex);
689 goto errorcleanup;
690 }
691 if ((chunk->lAddLength == (nAddLineCount + nContextLineCount)) &&
692 chunk->lRemoveLength == (nRemoveLineCount + nContextLineCount))
693 {
694 //chunk is finished
695 if (chunks)
696 chunks->chunks.Add(chunk);
697 else
698 delete chunk;
699 chunk = NULL;
700 nAddLineCount = 0;
701 nContextLineCount = 0;
702 nRemoveLineCount = 0;
703 state = 0;
704 }
705 }
706 break;
707 default:
708 ASSERT(FALSE);
709 } // switch (state)
710 } // for ( ;nIndex<m_PatchLines.GetCount(); nIndex++)
711 if (chunk)
712 {
713 m_sErrorMessage.LoadString(IDS_ERR_PATCH_CHUNKMISMATCH);
714 goto errorcleanup;
715 }
716 if (chunks)
717 m_arFileDiffs.Add(chunks);
718 return TRUE;
719 errorcleanup:
720 if (chunk)
721 delete chunk;
722 if (chunks)
723 {
724 for (int i=0; i<chunks->chunks.GetCount(); i++)
725 {
726 delete chunks->chunks.GetAt(i);
727 }
728 chunks->chunks.RemoveAll();
729 delete chunks;
730 }
731 FreeMemory();
732 return FALSE;
733 }
734
735 CString CPatch::GetFilename(int nIndex)
736 {
737 if (nIndex < 0)
738 return _T("");
739 if (nIndex < m_arFileDiffs.GetCount())
740 {
741 Chunks * c = m_arFileDiffs.GetAt(nIndex);
742 CString filepath = Strip(c->sFilePath);
743 return filepath;
744 }
745 return _T("");
746 }
747
748 CString CPatch::GetRevision(int nIndex)
749 {
750 if (nIndex < 0)
751 return 0;
752 if (nIndex < m_arFileDiffs.GetCount())
753 {
754 Chunks * c = m_arFileDiffs.GetAt(nIndex);
755 return c->sRevision;
756 }
757 return 0;
758 }
759
760 CString CPatch::GetFilename2(int nIndex)
761 {
762 if (nIndex < 0)
763 return _T("");
764 if (nIndex < m_arFileDiffs.GetCount())
765 {
766 Chunks * c = m_arFileDiffs.GetAt(nIndex);
767 CString filepath = Strip(c->sFilePath2);
768 return filepath;
769 }
770 return _T("");
771 }
772
773 CString CPatch::GetRevision2(int nIndex)
774 {
775 if (nIndex < 0)
776 return 0;
777 if (nIndex < m_arFileDiffs.GetCount())
778 {
779 Chunks * c = m_arFileDiffs.GetAt(nIndex);
780 return c->sRevision2;
781 }
782 return 0;
783 }
784
785 BOOL CPatch::PatchFile(const CString& sPath, const CString& sSavePath, const CString& sBaseFile)
786 {
787 if (PathIsDirectory(sPath))
788 {
789 m_sErrorMessage.Format(IDS_ERR_PATCH_INVALIDPATCHFILE, (LPCTSTR)sPath);
790 return FALSE;
791 }
792 // find the entry in the patch file which matches the full path given in sPath.
793 int nIndex = -1;
794 // use the longest path that matches
795 int nMaxMatch = 0;
796 for (int i=0; i<GetNumberOfFiles(); i++)
797 {
798 CString temppath = sPath;
799 CString temp = GetFilename(i);
800 temppath.Replace('/', '\\');
801 temp.Replace('/', '\\');
802 if (temppath.Mid(temppath.GetLength()-temp.GetLength()-1, 1).CompareNoCase(_T("\\"))==0)
803 {
804 temppath = temppath.Right(temp.GetLength());
805 if ((temp.CompareNoCase(temppath)==0))
806 {
807 if (nMaxMatch < temp.GetLength())
808 {
809 nMaxMatch = temp.GetLength();
810 nIndex = i;
811 }
812 }
813 }
814 else if (temppath.CompareNoCase(temp)==0)
815 {
816 if ((nIndex < 0)&&(! temp.IsEmpty()))
817 {
818 nIndex = i;
819 }
820 }
821 }
822 if (nIndex < 0)
823 {
824 m_sErrorMessage.Format(IDS_ERR_PATCH_FILENOTINPATCH, (LPCTSTR)sPath);
825 return FALSE;
826 }
827
828 CString sLine;
829 CString sPatchFile = sBaseFile.IsEmpty() ? sPath : sBaseFile;
830 if (PathFileExists(sPatchFile))
831 {
832 g_crasher.AddFile((LPCSTR)(LPCTSTR)sPatchFile, (LPCSTR)(LPCTSTR)_T("File to patch"));
833 }
834 CFileTextLines PatchLines;
835 CFileTextLines PatchLinesResult;
836 PatchLines.Load(sPatchFile);
837 PatchLinesResult = PatchLines; //.Copy(PatchLines);
838 PatchLines.CopySettings(&PatchLinesResult);
839
840 Chunks * chunks = m_arFileDiffs.GetAt(nIndex);
841
842 for (int i=0; i<chunks->chunks.GetCount(); i++)
843 {
844 Chunk * chunk = chunks->chunks.GetAt(i);
845 LONG lRemoveLine = chunk->lRemoveStart;
846 LONG lAddLine = chunk->lAddStart;
847 for (int j=0; j<chunk->arLines.GetCount(); j++)
848 {
849 CString sPatchLine = chunk->arLines.GetAt(j);
850 EOL ending = chunk->arEOLs[j];
851 if ((m_UnicodeType != CFileTextLines::UTF8)&&(m_UnicodeType != CFileTextLines::UTF8BOM))
852 {
853 if ((PatchLines.GetUnicodeType()==CFileTextLines::UTF8)||(m_UnicodeType == CFileTextLines::UTF8BOM))
854 {
855 // convert the UTF-8 contents in CString sPatchLine into a CStringA
856 sPatchLine = CUnicodeUtils::GetUnicode(CStringA(sPatchLine));
857 }
858 }
859 int nPatchState = (int)chunk->arLinesStates.GetAt(j);
860 switch (nPatchState)
861 {
862 case PATCHSTATE_REMOVED:
863 {
864 if ((lAddLine > PatchLines.GetCount())||(PatchLines.GetCount()==0))
865 {
866 m_sErrorMessage.Format(IDS_ERR_PATCH_DOESNOTMATCH, _T(""), (LPCTSTR)sPatchLine);
867 return FALSE;
868 }
869 if (lAddLine == 0)
870 lAddLine = 1;
871 if ((sPatchLine.Compare(PatchLines.GetAt(lAddLine-1))!=0)&&(!HasExpandedKeyWords(sPatchLine)))
872 {
873 m_sErrorMessage.Format(IDS_ERR_PATCH_DOESNOTMATCH, (LPCTSTR)sPatchLine, (LPCTSTR)PatchLines.GetAt(lAddLine-1));
874 return FALSE;
875 }
876 if (lAddLine > PatchLines.GetCount())
877 {
878 m_sErrorMessage.Format(IDS_ERR_PATCH_DOESNOTMATCH, (LPCTSTR)sPatchLine, _T(""));
879 return FALSE;
880 }
881 PatchLines.RemoveAt(lAddLine-1);
882 }
883 break;
884 case PATCHSTATE_ADDED:
885 {
886 if (lAddLine == 0)
887 lAddLine = 1;
888 PatchLines.InsertAt(lAddLine-1, sPatchLine, ending);
889 lAddLine++;
890 }
891 break;
892 case PATCHSTATE_CONTEXT:
893 {
894 if (lAddLine > PatchLines.GetCount())
895 {
896 m_sErrorMessage.Format(IDS_ERR_PATCH_DOESNOTMATCH, _T(""), (LPCTSTR)sPatchLine);
897 return FALSE;
898 }
899 if (lAddLine == 0)
900 lAddLine++;
901 if (lRemoveLine == 0)
902 lRemoveLine++;
903 if ((sPatchLine.Compare(PatchLines.GetAt(lAddLine-1))!=0) &&
904 (!HasExpandedKeyWords(sPatchLine)) &&
905 (lRemoveLine <= PatchLines.GetCount()) &&
906 (sPatchLine.Compare(PatchLines.GetAt(lRemoveLine-1))!=0))
907 {
908 if ((lAddLine < PatchLines.GetCount())&&(sPatchLine.Compare(PatchLines.GetAt(lAddLine))==0))
909 lAddLine++;
910 else if (((lAddLine + 1) < PatchLines.GetCount())&&(sPatchLine.Compare(PatchLines.GetAt(lAddLine+1))==0))
911 lAddLine += 2;
912 else if ((lRemoveLine < PatchLines.GetCount())&&(sPatchLine.Compare(PatchLines.GetAt(lRemoveLine))==0))
913 lRemoveLine++;
914 else
915 {
916 m_sErrorMessage.Format(IDS_ERR_PATCH_DOESNOTMATCH, (LPCTSTR)sPatchLine, (LPCTSTR)PatchLines.GetAt(lAddLine-1));
917 return FALSE;
918 }
919 }
920 lAddLine++;
921 lRemoveLine++;
922 }
923 break;
924 default:
925 ASSERT(FALSE);
926 break;
927 } // switch (nPatchState)
928 } // for (j=0; j<chunk->arLines.GetCount(); j++)
929 } // for (int i=0; i<chunks->chunks.GetCount(); i++)
930 if (!sSavePath.IsEmpty())
931 {
932 PatchLines.Save(sSavePath, false);
933 }
934 return TRUE;
935 }
936
937 BOOL CPatch::HasExpandedKeyWords(const CString& line)
938 {
939 if (line.Find(_T("$LastChangedDate"))>=0)
940 return TRUE;
941 if (line.Find(_T("$Date"))>=0)
942 return TRUE;
943 if (line.Find(_T("$LastChangedRevision"))>=0)
944 return TRUE;
945 if (line.Find(_T("$Rev"))>=0)
946 return TRUE;
947 if (line.Find(_T("$LastChangedBy"))>=0)
948 return TRUE;
949 if (line.Find(_T("$Author"))>=0)
950 return TRUE;
951 if (line.Find(_T("$HeadURL"))>=0)
952 return TRUE;
953 if (line.Find(_T("$URL"))>=0)
954 return TRUE;
955 if (line.Find(_T("$Id"))>=0)
956 return TRUE;
957 return FALSE;
958 }
959
960 CString CPatch::CheckPatchPath(const CString& path)
961 {
962 //first check if the path already matches
963 if (CountMatches(path) > (GetNumberOfFiles()/3))
964 return path;
965 //now go up the tree and try again
966 CString upperpath = path;
967 while (upperpath.ReverseFind('\\')>0)
968 {
969 upperpath = upperpath.Left(upperpath.ReverseFind('\\'));
970 if (CountMatches(upperpath) > (GetNumberOfFiles()/3))
971 return upperpath;
972 }
973 //still no match found. So try sub folders
974 bool isDir = false;
975 CString subpath;
976 CDirFileEnum filefinder(path);
977 while (filefinder.NextFile(subpath, &isDir))
978 {
979 if (!isDir)
980 continue;
981 if (g_GitAdminDir.IsAdminDirPath(subpath))
982 continue;
983 if (CountMatches(subpath) > (GetNumberOfFiles()/3))
984 return subpath;
985 }
986
987 // if a patch file only contains newly added files
988 // we can't really find the correct path.
989 // But: we can compare paths strings without the filenames
990 // and check if at least those match
991 upperpath = path;
992 while (upperpath.ReverseFind('\\')>0)
993 {
994 upperpath = upperpath.Left(upperpath.ReverseFind('\\'));
995 if (CountDirMatches(upperpath) > (GetNumberOfFiles()/3))
996 return upperpath;
997 }
998
999 return path;
1000 }
1001
1002 int CPatch::CountMatches(const CString& path)
1003 {
1004 int matches = 0;
1005 for (int i=0; i<GetNumberOfFiles(); ++i)
1006 {
1007 CString temp = GetFilename(i);
1008 temp.Replace('/', '\\');
1009 if (PathIsRelative(temp))
1010 temp = path + _T("\\")+ temp;
1011 if (PathFileExists(temp))
1012 matches++;
1013 }
1014 return matches;
1015 }
1016
1017 int CPatch::CountDirMatches(const CString& path)
1018 {
1019 int matches = 0;
1020 for (int i=0; i<GetNumberOfFiles(); ++i)
1021 {
1022 CString temp = GetFilename(i);
1023 temp.Replace('/', '\\');
1024 if (PathIsRelative(temp))
1025 temp = path + _T("\\")+ temp;
1026 // remove the filename
1027 temp = temp.Left(temp.ReverseFind('\\'));
1028 if (PathFileExists(temp))
1029 matches++;
1030 }
1031 return matches;
1032 }
1033
1034 BOOL CPatch::StripPrefixes(const CString& path)
1035 {
1036 int nSlashesMax = 0;
1037 for (int i=0; i<GetNumberOfFiles(); i++)
1038 {
1039 CString filename = GetFilename(i);
1040 filename.Replace('/','\\');
1041 int nSlashes = filename.Replace('\\','/');
1042 nSlashesMax = max(nSlashesMax,nSlashes);
1043 }
1044
1045 for (int nStrip=1;nStrip<nSlashesMax;nStrip++)
1046 {
1047 m_nStrip = nStrip;
1048 if ( CountMatches(path) > GetNumberOfFiles()/3 )
1049 {
1050 // Use current m_nStrip
1051 return TRUE;
1052 }
1053 }
1054
1055 // Stripping doesn't help so reset it again
1056 m_nStrip = 0;
1057 return FALSE;
1058 }
1059
1060 CString CPatch::Strip(const CString& filename)
1061 {
1062 CString s = filename;
1063 if ( m_nStrip>0 )
1064 {
1065 // Remove windows drive letter "c:"
1066 if ( s.GetLength()>2 && s[1]==':')
1067 {
1068 s = s.Mid(2);
1069 }
1070
1071 for (int nStrip=1;nStrip<=m_nStrip;nStrip++)
1072 {
1073 // "/home/ts/my-working-copy/dir/file.txt"
1074 // "home/ts/my-working-copy/dir/file.txt"
1075 // "ts/my-working-copy/dir/file.txt"
1076 // "my-working-copy/dir/file.txt"
1077 // "dir/file.txt"
1078 s = s.Mid(s.FindOneOf(_T("/\\"))+1);
1079 }
1080 }
1081 return s;
1082 }
1083
1084 CString CPatch::RemoveUnicodeBOM(const CString& str)
1085 {
1086 if (str.GetLength()==0)
1087 return str;
1088 if (str[0] == 0xFEFF)
1089 return str.Mid(1);
1090 return str;
1091 }
Windows Explorer Extension to Operate Git