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