OSDN Git Service

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