?  search:
summary | log | graphiclog1 | graphiclog2 | refs | edit | fork

06d07c4aaf22e3207c7dc5d9dc2cf966ca7fec65
[TortoiseGit.git] / src / Git / GitStatus.cpp
blob06d07c4aaf22e3207c7dc5d9dc2cf966ca7fec65
1 // TortoiseGit - a Windows shell extension for easy version control
2
3 // Copyright (C) 2008-2013 - TortoiseGit
4
5 // This program is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU General Public License
7 // as published by the Free Software Foundation; either version 2
8 // of the License, or (at your option) any later version.
9
10 // This program is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU General Public License for more details.
14
15 // You should have received a copy of the GNU General Public License
16 // along with this program; if not, write to the Free Software Foundation,
17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 //
19
20 #include "stdafx.h"
21 #include "registry.h"
22 #include "..\TortoiseShell\resource.h"
23 #include "GitStatus.h"
24 #include "UnicodeUtils.h"
25 #include "git.h"
26 #include "gitindex.h"
27 #include "shellcache.h"
28
29 extern CGitAdminDirMap g_AdminDirMap;
30 CGitIndexFileMap g_IndexFileMap;
31 CGitHeadFileMap g_HeadFileMap;
32 CGitIgnoreList g_IgnoreList;
33
34 GitStatus::GitStatus()
35 : status(NULL)
36 {
37 }
38
39 GitStatus::~GitStatus(void)
40 {
41 }
42
43 // static method
44 git_wc_status_kind GitStatus::GetAllStatus(const CTGitPath& path, git_depth_t depth, bool * assumeValid, bool * skipWorktree)
45 {
46 git_wc_status_kind statuskind;
47 BOOL err;
48 BOOL isDir;
49 CString sProjectRoot;
50
51 isDir = path.IsDirectory();
52 if (!path.HasAdminDir(&sProjectRoot))
53 return git_wc_status_none;
54
55 // rev.kind = git_opt_revision_unspecified;
56 statuskind = git_wc_status_none;
57
58 const BOOL bIsRecursive = (depth == git_depth_infinity || depth == git_depth_unknown); // taken from SVN source
59
60 CString sSubPath;
61 CString s = path.GetWinPathString();
62 if (s.GetLength() > sProjectRoot.GetLength())
63 {
64 if (sProjectRoot.GetLength() == 3 && sProjectRoot[1] == _T(':'))
65 sSubPath = s.Right(s.GetLength() - sProjectRoot.GetLength());
66 else
67 sSubPath = s.Right(s.GetLength() - sProjectRoot.GetLength() - 1/*otherwise it gets initial slash*/);
68 }
69
70 bool isfull = ((DWORD)CRegStdDWORD(_T("Software\\TortoiseGit\\CacheType"),
71 GetSystemMetrics(SM_REMOTESESSION) ? ShellCache::dll : ShellCache::exe) == ShellCache::dllFull);
72
73 if(isDir)
74 {
75 err = GetDirStatus(sProjectRoot,sSubPath,&statuskind, isfull,bIsRecursive,isfull,NULL, NULL);
76 // folders must not be displayed as added or deleted only as modified (this is for Shell Overlay-Modes)
77 if (statuskind == git_wc_status_unversioned && sSubPath.IsEmpty())
78 statuskind = git_wc_status_normal;
79 else if (statuskind == git_wc_status_deleted || statuskind == git_wc_status_added)
80 statuskind = git_wc_status_modified;
81 }
82 else
83 {
84 err = GetFileStatus(sProjectRoot, sSubPath, &statuskind, isfull, false, isfull, NULL, NULL, assumeValid, skipWorktree);
85 }
86
87 return statuskind;
88 }
89
90 // static method
91 git_wc_status_kind GitStatus::GetAllStatusRecursive(const CTGitPath& path)
92 {
93 return GetAllStatus(path, git_depth_infinity);
94 }
95
96 // static method
97 git_wc_status_kind GitStatus::GetMoreImportant(git_wc_status_kind status1, git_wc_status_kind status2)
98 {
99 if (GetStatusRanking(status1) >= GetStatusRanking(status2))
100 return status1;
101 return status2;
102 }
103 // static private method
104 int GitStatus::GetStatusRanking(git_wc_status_kind status)
105 {
106 switch (status)
107 {
108 case git_wc_status_none:
109 return 0;
110 case git_wc_status_unversioned:
111 return 1;
112 case git_wc_status_ignored:
113 return 2;
114 case git_wc_status_incomplete:
115 return 4;
116 case git_wc_status_normal:
117 case git_wc_status_external:
118 return 5;
119 case git_wc_status_added:
120 return 6;
121 case git_wc_status_missing:
122 return 7;
123 case git_wc_status_deleted:
124 return 8;
125 case git_wc_status_replaced:
126 return 9;
127 case git_wc_status_modified:
128 return 10;
129 case git_wc_status_merged:
130 return 11;
131 case git_wc_status_conflicted:
132 return 12;
133 case git_wc_status_obstructed:
134 return 13;
135 }
136 return 0;
137 }
138
139 void GitStatus::GetStatus(const CTGitPath& path, bool /*update*/ /* = false */, bool noignore /* = false */, bool /*noexternals*/ /* = false */)
140 {
141 // NOTE: unlike the SVN version this one does not cache the enumerated files, because in practice no code in all of
142 // Tortoise uses this, all places that call GetStatus create a temp GitStatus object which gets destroyed right
143 // after the call again
144
145 CString sProjectRoot;
146 if ( !path.HasAdminDir(&sProjectRoot) )
147 return;
148
149 bool isfull = ((DWORD)CRegStdDWORD(_T("Software\\TortoiseGit\\CacheType"),
150 GetSystemMetrics(SM_REMOTESESSION) ? ShellCache::dll : ShellCache::exe) == ShellCache::dllFull);
151
152 {
153 LPCTSTR lpszSubPath = NULL;
154 CString sSubPath;
155 CString s = path.GetWinPathString();
156 if (s.GetLength() > sProjectRoot.GetLength())
157 {
158 sSubPath = s.Right(s.GetLength() - sProjectRoot.GetLength());
159 lpszSubPath = sSubPath;
160 // skip initial slash if necessary
161 if (*lpszSubPath == _T('\\'))
162 ++lpszSubPath;
163 }
164
165 m_status.prop_status = m_status.text_status = git_wc_status_none;
166 m_status.assumeValid = false;
167 m_status.skipWorktree = false;
168
169 if(path.IsDirectory())
170 {
171 m_err = GetDirStatus(sProjectRoot,CString(lpszSubPath),&m_status.text_status , isfull, false,!noignore, NULL, NULL);
172
173 }
174 else
175 {
176 m_err = GetFileStatus(sProjectRoot, CString(lpszSubPath), &m_status.text_status ,isfull, false,!noignore, NULL,NULL, &m_status.assumeValid, &m_status.skipWorktree);
177 }
178 }
179
180 // Error present if function is not under version control
181 if (m_err)
182 {
183 status = NULL;
184 return;
185 }
186
187 status = &m_status;
188 }
189
190 void GitStatus::GetStatusString(git_wc_status_kind status, size_t buflen, TCHAR * string)
191 {
192 TCHAR * buf;
193 switch (status)
194 {
195 case git_wc_status_none:
196 buf = _T("none\0");
197 break;
198 case git_wc_status_unversioned:
199 buf = _T("unversioned\0");
200 break;
201 case git_wc_status_normal:
202 buf = _T("normal\0");
203 break;
204 case git_wc_status_added:
205 buf = _T("added\0");
206 break;
207 case git_wc_status_missing:
208 buf = _T("missing\0");
209 break;
210 case git_wc_status_deleted:
211 buf = _T("deleted\0");
212 break;
213 case git_wc_status_replaced:
214 buf = _T("replaced\0");
215 break;
216 case git_wc_status_modified:
217 buf = _T("modified\0");
218 break;
219 case git_wc_status_merged:
220 buf = _T("merged\0");
221 break;
222 case git_wc_status_conflicted:
223 buf = _T("conflicted\0");
224 break;
225 case git_wc_status_obstructed:
226 buf = _T("obstructed\0");
227 break;
228 case git_wc_status_ignored:
229 buf = _T("ignored");
230 break;
231 case git_wc_status_external:
232 buf = _T("external");
233 break;
234 case git_wc_status_incomplete:
235 buf = _T("incomplete\0");
236 break;
237 default:
238 buf = _T("\0");
239 break;
240 }
241 _stprintf_s(string, buflen, _T("%s"), buf);
242 }
243
244 void GitStatus::GetStatusString(HINSTANCE hInst, git_wc_status_kind status, TCHAR * string, int size, WORD lang)
245 {
246 switch (status)
247 {
248 case git_wc_status_none:
249 LoadStringEx(hInst, IDS_STATUSNONE, string, size, lang);
250 break;
251 case git_wc_status_unversioned:
252 LoadStringEx(hInst, IDS_STATUSUNVERSIONED, string, size, lang);
253 break;
254 case git_wc_status_normal:
255 LoadStringEx(hInst, IDS_STATUSNORMAL, string, size, lang);
256 break;
257 case git_wc_status_added:
258 LoadStringEx(hInst, IDS_STATUSADDED, string, size, lang);
259 break;
260 case git_wc_status_missing:
261 LoadStringEx(hInst, IDS_STATUSABSENT, string, size, lang);
262 break;
263 case git_wc_status_deleted:
264 LoadStringEx(hInst, IDS_STATUSDELETED, string, size, lang);
265 break;
266 case git_wc_status_replaced:
267 LoadStringEx(hInst, IDS_STATUSREPLACED, string, size, lang);
268 break;
269 case git_wc_status_modified:
270 LoadStringEx(hInst, IDS_STATUSMODIFIED, string, size, lang);
271 break;
272 case git_wc_status_merged:
273 LoadStringEx(hInst, IDS_STATUSMERGED, string, size, lang);
274 break;
275 case git_wc_status_conflicted:
276 LoadStringEx(hInst, IDS_STATUSCONFLICTED, string, size, lang);
277 break;
278 case git_wc_status_ignored:
279 LoadStringEx(hInst, IDS_STATUSIGNORED, string, size, lang);
280 break;
281 case git_wc_status_obstructed:
282 LoadStringEx(hInst, IDS_STATUSOBSTRUCTED, string, size, lang);
283 break;
284 case git_wc_status_external:
285 LoadStringEx(hInst, IDS_STATUSEXTERNAL, string, size, lang);
286 break;
287 case git_wc_status_incomplete:
288 LoadStringEx(hInst, IDS_STATUSINCOMPLETE, string, size, lang);
289 break;
290 default:
291 LoadStringEx(hInst, IDS_STATUSNONE, string, size, lang);
292 break;
293 }
294 }
295
296 int GitStatus::LoadStringEx(HINSTANCE hInstance, UINT uID, LPTSTR lpBuffer, int nBufferMax, WORD wLanguage)
297 {
298 const STRINGRESOURCEIMAGE* pImage;
299 const STRINGRESOURCEIMAGE* pImageEnd;
300 ULONG nResourceSize;
301 HGLOBAL hGlobal;
302 UINT iIndex;
303 int ret;
304
305 HRSRC hResource = FindResourceEx(hInstance, RT_STRING, MAKEINTRESOURCE(((uID>>4)+1)), wLanguage);
306 if (!hResource)
307 {
308 // try the default language before giving up!
309 hResource = FindResource(hInstance, MAKEINTRESOURCE(((uID>>4)+1)), RT_STRING);
310 if (!hResource)
311 return 0;
312 }
313 hGlobal = LoadResource(hInstance, hResource);
314 if (!hGlobal)
315 return 0;
316 pImage = (const STRINGRESOURCEIMAGE*)::LockResource(hGlobal);
317 if(!pImage)
318 return 0;
319
320 nResourceSize = ::SizeofResource(hInstance, hResource);
321 pImageEnd = (const STRINGRESOURCEIMAGE*)(LPBYTE(pImage)+nResourceSize);
322 iIndex = uID&0x000f;
323
324 while ((iIndex > 0) && (pImage < pImageEnd))
325 {
326 pImage = (const STRINGRESOURCEIMAGE*)(LPBYTE(pImage)+(sizeof(STRINGRESOURCEIMAGE)+(pImage->nLength*sizeof(WCHAR))));
327 iIndex--;
328 }
329 if (pImage >= pImageEnd)
330 return 0;
331 if (pImage->nLength == 0)
332 return 0;
333
334 ret = pImage->nLength;
335 if (pImage->nLength > nBufferMax)
336 {
337 wcsncpy_s(lpBuffer, nBufferMax, pImage->achString, pImage->nLength-1);
338 lpBuffer[nBufferMax-1] = 0;
339 }
340 else
341 {
342 wcsncpy_s(lpBuffer, nBufferMax, pImage->achString, pImage->nLength);
343 lpBuffer[ret] = 0;
344 }
345 return ret;
346 }
347
348 typedef CComCritSecLock<CComCriticalSection> CAutoLocker;
349
350 int GitStatus::GetFileStatus(const CString &gitdir, const CString &pathParam, git_wc_status_kind * status,BOOL IsFull, BOOL /*IsRecursive*/,BOOL IsIgnore, FIll_STATUS_CALLBACK callback, void *pData, bool * assumeValid, bool * skipWorktree)
351 {
352 try
353 {
354 CString path = pathParam;
355
356 TCHAR oldpath[MAX_PATH+1];
357 memset(oldpath,0,MAX_PATH+1);
358
359 path.Replace(_T('\\'),_T('/'));
360
361 CString lowcasepath =path;
362 lowcasepath.MakeLower();
363
364 if(status)
365 {
366 git_wc_status_kind st = git_wc_status_none;
367 CGitHash hash;
368
369 g_IndexFileMap.GetFileStatus(gitdir, path, &st, IsFull, false, callback, pData, &hash, true, assumeValid, skipWorktree);
370
371 if( st == git_wc_status_conflicted )
372 {
373 *status =st;
374 if(callback)
375 callback(gitdir + _T("/") + path, st, false, pData, *assumeValid, *skipWorktree);
376 return 0;
377 }
378
379 if( st == git_wc_status_unversioned )
380 {
381 if(!IsIgnore)
382 {
383 *status = git_wc_status_unversioned;
384 if(callback)
385 callback(gitdir + _T("/") + path, *status, false, pData, *assumeValid, *skipWorktree);
386 return 0;
387 }
388
389 if( g_IgnoreList.CheckIgnoreChanged(gitdir,path))
390 {
391 g_IgnoreList.LoadAllIgnoreFile(gitdir,path);
392 }
393 if( g_IgnoreList.IsIgnore(path, gitdir) )
394 {
395 st = git_wc_status_ignored;
396 }
397 *status = st;
398 if(callback)
399 callback(gitdir + _T("/") + path, st, false, pData, *assumeValid, *skipWorktree);
400
401 return 0;
402 }
403
404 if( st == git_wc_status_normal && IsFull)
405 {
406 {
407 g_HeadFileMap.CheckHeadAndUpdate(gitdir);
408
409 SHARED_TREE_PTR treeptr = g_HeadFileMap.SafeGet(gitdir);
410
411 // Check Head Tree Hash;
412 {
413 //add item
414
415 int start =SearchInSortVector(*treeptr,lowcasepath.GetBuffer(),-1);
416 lowcasepath.ReleaseBuffer();
417
418 if(start<0)
419 {
420 *status =st=git_wc_status_added;
421 ATLTRACE(_T("File miss in head tree %s"), path);
422 if(callback)
423 callback(gitdir + _T("/") + path, st, false, pData, *assumeValid, *skipWorktree);
424 return 0;
425 }
426
427 //staged and not commit
428 if( treeptr->at(start).m_Hash != hash )
429 {
430 *status =st=git_wc_status_modified;
431 if(callback)
432 callback(gitdir + _T("/") + path, st, false, pData, *assumeValid, *skipWorktree);
433 return 0;
434 }
435 }
436 }
437 }
438 *status =st;
439 if(callback)
440 callback(gitdir + _T("/") + path, st, false, pData, *assumeValid, *skipWorktree);
441 return 0;
442 }
443 }
444 catch(...)
445 {
446 if(status)
447 *status = git_wc_status_none;
448 return -1;
449 }
450
451 return 0;
452
453 }
454
455 bool GitStatus::HasIgnoreFilesChanged(const CString &gitdir, const CString &subpaths)
456 {
457 return g_IgnoreList.CheckIgnoreChanged(gitdir, subpaths);
458 }
459
460 int GitStatus::LoadIgnoreFile(const CString &gitdir,const CString &subpaths)
461 {
462 return g_IgnoreList.LoadAllIgnoreFile(gitdir,subpaths);
463 }
464 int GitStatus::IsUnderVersionControl(const CString &gitdir, const CString &path, bool isDir,bool *isVersion)
465 {
466 if (g_IndexFileMap.IsUnderVersionControl(gitdir, path, isDir, isVersion))
467 return 1;
468 if (!*isVersion)
469 return g_HeadFileMap.IsUnderVersionControl(gitdir, path, isDir, isVersion);
470 return 0;
471 }
472
473 __int64 GitStatus::GetIndexFileTime(const CString &gitdir)
474 {
475 SHARED_INDEX_PTR ptr=g_IndexFileMap.SafeGet(gitdir);
476 if(ptr.get() == NULL)
477 return 0;
478
479 return ptr->m_LastModifyTime;
480 }
481
482 int GitStatus::IsIgnore(const CString &gitdir, const CString &path, bool *isIgnore)
483 {
484 if(::g_IgnoreList.CheckIgnoreChanged(gitdir,path))
485 g_IgnoreList.LoadAllIgnoreFile(gitdir,path);
486
487 *isIgnore = g_IgnoreList.IsIgnore(path,gitdir);
488
489 return 0;
490 }
491
492 static bool SortFileName(CGitFileName &Item1, CGitFileName &Item2)
493 {
494 return Item1.m_FileName.Compare(Item2.m_FileName)<0;
495 }
496
497 int GitStatus::GetFileList(const CString &gitdir, const CString &subpath, std::vector<CGitFileName> &list)
498 {
499 WIN32_FIND_DATA data;
500 HANDLE handle=::FindFirstFile(gitdir+_T("\\")+subpath+_T("\\*.*"), &data);
501 do
502 {
503 if(_tcscmp(data.cFileName, _T(".git")) == 0)
504 continue;
505
506 if(_tcscmp(data.cFileName, _T(".")) == 0)
507 continue;
508
509 if(_tcscmp(data.cFileName, _T("..")) == 0)
510 continue;
511
512 CGitFileName filename;
513
514 filename.m_CaseFileName = filename.m_FileName = data.cFileName;
515 filename.m_FileName.MakeLower();
516
517 if(data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
518 {
519 filename.m_FileName += _T('/');
520 }
521
522 list.push_back(filename);
523
524 }while(::FindNextFile(handle, &data));
525
526 FindClose(handle);
527
528 std::sort(list.begin(), list.end(), SortFileName);
529 return 0;
530 }
531
532 int GitStatus::EnumDirStatus(const CString &gitdir,const CString &subpath,git_wc_status_kind * status,BOOL IsFul, BOOL IsRecursive, BOOL IsIgnore, FIll_STATUS_CALLBACK callback, void *pData)
533 {
534 try
535 {
536 TCHAR oldpath[MAX_PATH+1];
537 memset(oldpath,0,MAX_PATH+1);
538
539 CString path =subpath;
540
541 path.Replace(_T('\\'),_T('/'));
542 if(!path.IsEmpty())
543 if(path[path.GetLength()-1] != _T('/'))
544 path += _T('/'); //Add trail / to show it is directory, not file name.
545
546 CString lowcasepath = path;
547 lowcasepath.MakeLower();
548
549 std::vector<CGitFileName> filelist;
550 GetFileList(gitdir, subpath, filelist);
551
552 if(status)
553 {
554 g_IndexFileMap.CheckAndUpdate(gitdir,true);
555
556 g_HeadFileMap.CheckHeadAndUpdate(gitdir);
557
558 SHARED_INDEX_PTR indexptr = g_IndexFileMap.SafeGet(gitdir);
559 SHARED_TREE_PTR treeptr = g_HeadFileMap.SafeGet(gitdir);
560
561 std::vector<CGitFileName>::iterator it;
562
563 // new git working tree has no index file
564 if (indexptr.get() == NULL)
565 {
566 for (it = filelist.begin(); it < filelist.end(); ++it)
567 {
568 CString casepath = path + it->m_CaseFileName;
569
570 bool bIsDir = false;
571 if (casepath.GetLength() > 0 && casepath[casepath.GetLength() - 1] == _T('/'))
572 bIsDir = true;
573
574 if (bIsDir) /*check if it is directory*/
575 {
576 if (::PathFileExists(gitdir + casepath + _T("\\.git")))
577 { /* That is git submodule */
578 *status = git_wc_status_unknown;
579 if (callback)
580 callback(gitdir + _T("/") + casepath, *status, bIsDir, pData, false, false);
581 continue;
582 }
583 }
584
585 if (IsIgnore)
586 {
587 if (g_IgnoreList.CheckIgnoreChanged(gitdir, casepath))
588 g_IgnoreList.LoadAllIgnoreFile(gitdir, casepath);
589
590 if (g_IgnoreList.IsIgnore(casepath, gitdir))
591 *status = git_wc_status_ignored;
592 else if (bIsDir)
593 continue;
594 else
595 *status = git_wc_status_unversioned;
596 }
597 else if (bIsDir)
598 continue;
599 else
600 *status = git_wc_status_unversioned;
601
602 if(callback)
603 callback(gitdir + _T("/") + casepath, *status, bIsDir, pData, false, false);
604 }
605 return 0;
606 }
607
608 CString onepath;
609 CString casepath;
610 for (it = filelist.begin(); it < filelist.end(); ++it)
611 {
612 casepath=onepath = path;
613 onepath.MakeLower();
614 onepath += it->m_FileName;
615 casepath += it->m_CaseFileName;
616
617 LPTSTR onepathBuffer = onepath.GetBuffer();
618 int pos = SearchInSortVector(*indexptr, onepathBuffer, onepath.GetLength());
619 int posintree = SearchInSortVector(*treeptr, onepathBuffer, onepath.GetLength());
620 onepath.ReleaseBuffer();
621
622 bool bIsDir =false;
623 if(onepath.GetLength()>0 && onepath[onepath.GetLength()-1] == _T('/'))
624 bIsDir =true;
625
626 if(pos <0 && posintree<0)
627 {
628 if(onepath.GetLength() ==0)
629 continue;
630
631 if(bIsDir) /*check if it is directory*/
632 {
633 if(::PathFileExists(gitdir+onepath+_T("/.git")))
634 { /* That is git submodule */
635 *status = git_wc_status_unknown;
636 if(callback)
637 callback(gitdir + _T("/") + casepath, *status, bIsDir, pData, false, false);
638 continue;
639 }
640 }
641
642 if(!IsIgnore)
643 {
644 *status = git_wc_status_unversioned;
645 if(callback)
646 callback(gitdir + _T("/") + casepath, *status, bIsDir, pData, false, false);
647 continue;
648 }
649
650 if(::g_IgnoreList.CheckIgnoreChanged(gitdir,casepath))
651 g_IgnoreList.LoadAllIgnoreFile(gitdir,casepath);
652
653 if(g_IgnoreList.IsIgnore(casepath,gitdir))
654 *status = git_wc_status_ignored;
655 else
656 *status = git_wc_status_unversioned;
657
658 if(callback)
659 callback(gitdir + _T("/") + casepath, *status, bIsDir, pData, false, false);
660
661 }
662 else if(pos <0 && posintree>=0) /* check if file delete in index */
663 {
664 *status = git_wc_status_deleted;
665 if(callback)
666 callback(gitdir + _T("/") + casepath, *status, bIsDir, pData, false, false);
667
668 }
669 else if(pos >=0 && posintree <0) /* Check if file added */
670 {
671 *status = git_wc_status_added;
672 if(callback)
673 callback(gitdir + _T("/") + casepath, *status, bIsDir, pData, false, false);
674 }
675 else
676 {
677 if(onepath.GetLength() ==0)
678 continue;
679
680 if(onepath[onepath.GetLength()-1] == _T('/'))
681 {
682 *status = git_wc_status_normal;
683 if(callback)
684 callback(gitdir + _T("/") + casepath, *status, bIsDir, pData, false, false);
685 }
686 else
687 {
688 bool assumeValid = false;
689 bool skipWorktree = false;
690 git_wc_status_kind filestatus;
691 GetFileStatus(gitdir, casepath, &filestatus, IsFul, IsRecursive, IsIgnore, callback, pData, &assumeValid, &skipWorktree);
692 }
693 }
694
695 }/*End of For*/
696
697 /* Check deleted file in system */
698 LPTSTR lowcasepathBuffer = lowcasepath.GetBuffer();
699 int start=0, end=0;
700 int pos=SearchInSortVector(*indexptr, lowcasepathBuffer, lowcasepath.GetLength());
701
702 if (GetRangeInSortVector(*indexptr, lowcasepathBuffer, lowcasepath.GetLength(), &start, &end, pos) == 0)
703 {
704 CGitIndexList::iterator it;
705 CString oldstring;
706
707 for (it = indexptr->begin() + start; it <= indexptr->begin() + end; ++it)
708 {
709 int start = lowcasepath.GetLength();
710 int index = (*it).m_FileName.Find(_T('/'), start);
711 if(index<0)
712 index = (*it).m_FileName.GetLength();
713
714 CString filename = (*it).m_FileName.Mid(start, index-start);
715 if(oldstring != filename)
716 {
717 oldstring = filename;
718 if(SearchInSortVector(filelist, filename.GetBuffer(), filename.GetLength())<0)
719 {
720 *status = git_wc_status_deleted;
721 if(callback)
722 callback(gitdir + _T("/") + filename, *status, false, pData, false, false);
723 }
724 }
725 }
726 }
727
728 start = end =0;
729 pos=SearchInSortVector(*treeptr, lowcasepathBuffer, lowcasepath.GetLength());
730 if (GetRangeInSortVector(*treeptr, lowcasepathBuffer, lowcasepath.GetLength(), &start, &end, pos) == 0)
731 {
732 CGitHeadFileList::iterator it;
733 CString oldstring;
734
735 for (it = treeptr->begin() + start; it <= treeptr->begin() + end; ++it)
736 {
737 int start = lowcasepath.GetLength();
738 int index = (*it).m_FileName.Find(_T('/'), start);
739 if(index<0)
740 index = (*it).m_FileName.GetLength();
741
742 CString filename = (*it).m_FileName.Mid(start, index-start);
743 if(oldstring != filename)
744 {
745 oldstring = filename;
746 if(SearchInSortVector(filelist, filename.GetBuffer(), filename.GetLength())<0)
747 {
748 *status = git_wc_status_deleted;
749 if(callback)
750 callback(gitdir + _T("/") + (*it).m_FileName, *status, false, pData, false, false);
751 }
752 }
753 }
754 }
755 lowcasepath.ReleaseBuffer();
756
757 }/*End of if status*/
758 }catch(...)
759 {
760 return -1;
761 }
762 return 0;
763
764 }
765 int GitStatus::GetDirStatus(const CString &gitdir,const CString &subpath,git_wc_status_kind * status,BOOL IsFul, BOOL IsRecursive,BOOL IsIgnore,FIll_STATUS_CALLBACK callback,void *pData)
766 {
767 try
768 {
769 TCHAR oldpath[MAX_PATH+1];
770 memset(oldpath,0,MAX_PATH+1);
771
772 CString path =subpath;
773
774 path.Replace(_T('\\'),_T('/'));
775 if(!path.IsEmpty())
776 if(path[path.GetLength()-1] != _T('/'))
777 path += _T('/'); //Add trail / to show it is directory, not file name.
778
779 CString lowcasepath = path;
780 lowcasepath.MakeLower();
781
782 if(status)
783 {
784 g_IndexFileMap.CheckAndUpdate(gitdir, true);
785
786 SHARED_INDEX_PTR indexptr = g_IndexFileMap.SafeGet(gitdir);
787
788 if (indexptr == NULL)
789 {
790 *status = git_wc_status_unversioned;
791 return 0;
792 }
793
794 int pos=SearchInSortVector(*indexptr,lowcasepath.GetBuffer(),lowcasepath.GetLength());
795 lowcasepath.ReleaseBuffer();
796
797 //Not In Version Contorl
798 if(pos<0)
799 {
800 if(!IsIgnore)
801 {
802 *status = git_wc_status_unversioned;
803 if(callback)
804 callback(gitdir + _T("/") + path, *status, false, pData, false, false);
805 return 0;
806 }
807 //Check ignore always.
808 {
809 if(::g_IgnoreList.CheckIgnoreChanged(gitdir,path))
810 g_IgnoreList.LoadAllIgnoreFile(gitdir,path);
811
812 if(g_IgnoreList.IsIgnore(path,gitdir))
813 *status = git_wc_status_ignored;
814 else
815 *status = git_wc_status_unversioned;
816
817 g_HeadFileMap.CheckHeadAndUpdate(gitdir, false);
818
819 SHARED_TREE_PTR treeptr = g_HeadFileMap.SafeGet(gitdir);
820 //Check init repository
821 if (treeptr->HeadIsEmpty() && path.IsEmpty())
822 *status = git_wc_status_normal;
823 }
824
825 }
826 else // In version control
827 {
828 *status = git_wc_status_normal;
829
830 int start=0;
831 int end=0;
832 if(path.IsEmpty())
833 {
834 start=0;
835 end = (int)indexptr->size() - 1;
836 }
837 LPTSTR lowcasepathBuffer = lowcasepath.GetBuffer();
838 GetRangeInSortVector(*indexptr, lowcasepathBuffer, lowcasepath.GetLength(), &start, &end, pos);
839 lowcasepath.ReleaseBuffer();
840 CGitIndexList::iterator it;
841
842 it = indexptr->begin()+start;
843
844 // Check Conflict;
845 for (int i = start; i <= end; ++i)
846 {
847 if (((*it).m_Flags & GIT_IDXENTRY_STAGEMASK) !=0)
848 {
849 *status = git_wc_status_conflicted;
850 if(callback)
851 {
852 int dirpos = (*it).m_FileName.Find(_T('/'), path.GetLength());
853 if(dirpos<0 || IsRecursive)
854 callback(gitdir + _T("\\") + it->m_FileName, git_wc_status_conflicted, false, pData, false, false);
855 }
856 else
857 break;
858 }
859 ++it;
860 }
861
862 if( IsFul && (*status != git_wc_status_conflicted))
863 {
864 *status = git_wc_status_normal;
865
866 g_HeadFileMap.CheckHeadAndUpdate(gitdir);
867
868 //Check Add
869 it = indexptr->begin()+start;
870
871
872 {
873 //Check if new init repository
874 SHARED_TREE_PTR treeptr = g_HeadFileMap.SafeGet(gitdir);
875
876 if (!treeptr->empty() || treeptr->HeadIsEmpty())
877 {
878 for (int i = start; i<= end; ++i)
879 {
880 pos =SearchInSortVector(*treeptr, (*it).m_FileName.GetBuffer(), -1);
881 (*it).m_FileName.ReleaseBuffer();
882
883 if(pos < 0)
884 {
885 *status = max(git_wc_status_added, *status); // added file found
886 if(callback)
887 {
888 int dirpos = (*it).m_FileName.Find(_T('/'), path.GetLength());
889 if(dirpos<0 || IsRecursive)
890 callback(gitdir + _T("\\") + it->m_FileName, git_wc_status_added, false, pData, false, false);
891
892 }
893 else
894 break;
895 }
896
897 if( pos>=0 && treeptr->at(pos).m_Hash != (*it).m_IndexHash)
898 {
899 *status = max(git_wc_status_modified, *status); // modified file found
900 if(callback)
901 {
902 int dirpos = (*it).m_FileName.Find(_T('/'), path.GetLength());
903 if(dirpos<0 || IsRecursive)
904 callback(gitdir + _T("\\") + it->m_FileName, git_wc_status_modified, false, pData, ((*it).m_Flags & GIT_IDXENTRY_VALID) && !((*it).m_Flags & GIT_IDXENTRY_SKIP_WORKTREE), ((*it).m_Flags & GIT_IDXENTRY_SKIP_WORKTREE) != 0);
905
906 }
907 else
908 break;
909 }
910
911 ++it;
912 }
913
914 //Check Delete
915 if( *status == git_wc_status_normal )
916 {
917 pos = SearchInSortVector(*treeptr, lowcasepathBuffer, lowcasepath.GetLength());
918 if(pos <0)
919 {
920 *status = max(git_wc_status_added, *status); // added file found
921
922 }
923 else
924 {
925 int hstart,hend;
926 GetRangeInSortVector(*treeptr, lowcasepathBuffer, lowcasepath.GetLength(), &hstart, &hend, pos);
927 CGitHeadFileList::iterator hit;
928 hit = treeptr->begin() + hstart;
929 CGitHeadFileList::iterator lastElement = treeptr->end();
930 for (int i = hstart; i <= hend && hit != lastElement; ++i)
931 {
932 if( SearchInSortVector(*indexptr,(*hit).m_FileName.GetBuffer(),-1) < 0)
933 {
934 (*hit).m_FileName.ReleaseBuffer();
935 *status = max(git_wc_status_deleted, *status); // deleted file found
936 break;
937 }
938 (*hit).m_FileName.ReleaseBuffer();
939 ++hit;
940 }
941 }
942 }
943 }
944 }/* End lock*/
945 }
946 lowcasepath.ReleaseBuffer();
947 // If define callback, it need update each file status.
948 // If not define callback, status == git_wc_status_conflicted, needn't check each file status
949 // because git_wc_status_conflicted is highest.s
950 if(callback || (*status != git_wc_status_conflicted))
951 {
952 //Check File Time;
953 //if(IsRecursive)
954 {
955 CString sub, currentPath;
956 it = indexptr->begin()+start;
957 for (int i = start; i <= end; ++i, ++it)
958 {
959 if( !IsRecursive )
960 {
961 //skip child directory
962 int pos = (*it).m_FileName.Find(_T('/'), path.GetLength());
963
964 if( pos > 0)
965 {
966 currentPath = (*it).m_FileName.Left(pos);
967 if( callback && (sub != currentPath) )
968 {
969 sub = currentPath;
970 ATLTRACE(_T("index subdir %s\n"),sub);
971 if(callback) callback(gitdir + _T("\\") + sub,
972 git_wc_status_normal, true, pData, false, false);
973 }
974 continue;
975 }
976 }
977
978 git_wc_status_kind filestatus = git_wc_status_none;
979 bool assumeValid = false;
980 bool skipWorktree = false;
981 GetFileStatus(gitdir, (*it).m_FileName, &filestatus, IsFul, IsRecursive, IsIgnore, callback, pData, &assumeValid, &skipWorktree);
982 }
983 }
984 }
985 }
986
987 if(callback) callback(gitdir + _T("/") + subpath, *status, true, pData, false, false);
988 }
989
990 }catch(...)
991 {
992 if(status)
993 *status = git_wc_status_none;
994 return -1;
995 }
996
997 return 0;
998 }
999
1000 bool GitStatus::IsExistIndexLockFile(const CString &gitdir)
1001 {
1002 CString sDirName= gitdir;
1003
1004 for (;;)
1005 {
1006 if(PathFileExists(sDirName + _T("\\.git")))
1007 {
1008 if(PathFileExists(g_AdminDirMap.GetAdminDir(sDirName) + _T("index.lock")))
1009 return true;
1010 else
1011 return false;
1012 }
1013
1014 int x = sDirName.ReverseFind(_T('\\'));
1015 if (x < 2)
1016 return false;
1017
1018 sDirName = sDirName.Left(x);
1019 }
1020 }
Windows Explorer Extension to Operate Git