src/Git/GitStatus.cpp

   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                 path.Replace(_T('\\'),_T('/'));
 357
 358                 CString lowcasepath =path;
 359                 lowcasepath.MakeLower();
 360
 361                 if(status)
 362                 {
 363                         git_wc_status_kind st = git_wc_status_none;
 364                         CGitHash hash;
 365
 366                         g_IndexFileMap.GetFileStatus(gitdir, path, &st, IsFull, false, callback, pData, &hash, true, assumeValid, skipWorktree);
 367
 368                         if( st == git_wc_status_conflicted )
 369                         {
 370                                 *status =st;
 371                                 if(callback)
 372                                         callback(gitdir + _T("/") + path, st, false, pData, *assumeValid, *skipWorktree);
 373                                 return 0;
 374                         }
 375
 376                         if( st == git_wc_status_unversioned )
 377                         {
 378                                 if(!IsIgnore)
 379                                 {
 380                                         *status = git_wc_status_unversioned;
 381                                         if(callback)
 382                                                 callback(gitdir + _T("/") + path, *status, false, pData, *assumeValid, *skipWorktree);
 383                                         return 0;
 384                                 }
 385
 386                                 if( g_IgnoreList.CheckIgnoreChanged(gitdir,path))
 387                                 {
 388                                         g_IgnoreList.LoadAllIgnoreFile(gitdir,path);
 389                                 }
 390                                 if( g_IgnoreList.IsIgnore(path, gitdir) )
 391                                 {
 392                                         st = git_wc_status_ignored;
 393                                 }
 394                                 *status = st;
 395                                 if(callback)
 396                                         callback(gitdir + _T("/") + path, st, false, pData, *assumeValid, *skipWorktree);
 397
 398                                 return 0;
 399                         }
 400
 401                         if( st == git_wc_status_normal && IsFull)
 402                         {
 403                                 {
 404                                         g_HeadFileMap.CheckHeadAndUpdate(gitdir);
 405
 406                                         SHARED_TREE_PTR treeptr = g_HeadFileMap.SafeGet(gitdir);
 407
 408                                         // Check Head Tree Hash;
 409                                         {
 410                                                 //add item
 411
 412                                                 int start =SearchInSortVector(*treeptr,lowcasepath.GetBuffer(),-1);
 413                                                 lowcasepath.ReleaseBuffer();
 414
 415                                                 if(start<0)
 416                                                 {
 417                                                         *status =st=git_wc_status_added;
 418                                                         ATLTRACE(_T("File miss in head tree %s"), path);
 419                                                         if(callback)
 420                                                                 callback(gitdir + _T("/") + path, st, false, pData, *assumeValid, *skipWorktree);
 421                                                         return 0;
 422                                                 }
 423
 424                                                 //staged and not commit
 425                                                 if( treeptr->at(start).m_Hash != hash )
 426                                                 {
 427                                                         *status =st=git_wc_status_modified;
 428                                                         if(callback)
 429                                                                 callback(gitdir + _T("/") + path, st, false, pData, *assumeValid, *skipWorktree);
 430                                                         return 0;
 431                                                 }
 432                                         }
 433                                 }
 434                         }
 435                         *status =st;
 436                         if(callback)
 437                                 callback(gitdir + _T("/") + path, st, false, pData, *assumeValid, *skipWorktree);
 438                         return 0;
 439                 }
 440         }
 441         catch(...)
 442         {
 443                 if(status)
 444                         *status = git_wc_status_none;
 445                 return -1;
 446         }
 447
 448         return 0;
 449
 450 }
 451
 452 bool GitStatus::HasIgnoreFilesChanged(const CString &gitdir, const CString &subpaths)
 453 {
 454         return g_IgnoreList.CheckIgnoreChanged(gitdir, subpaths);
 455 }
 456
 457 int GitStatus::LoadIgnoreFile(const CString &gitdir,const CString &subpaths)
 458 {
 459         return g_IgnoreList.LoadAllIgnoreFile(gitdir,subpaths);
 460 }
 461 int GitStatus::IsUnderVersionControl(const CString &gitdir, const CString &path, bool isDir,bool *isVersion)
 462 {
 463         if (g_IndexFileMap.IsUnderVersionControl(gitdir, path, isDir, isVersion))
 464                 return 1;
 465         if (!*isVersion)
 466                 return g_HeadFileMap.IsUnderVersionControl(gitdir, path, isDir, isVersion);
 467         return 0;
 468 }
 469
 470 __int64 GitStatus::GetIndexFileTime(const CString &gitdir)
 471 {
 472         SHARED_INDEX_PTR ptr=g_IndexFileMap.SafeGet(gitdir);
 473         if(ptr.get() == NULL)
 474                 return 0;
 475
 476         return ptr->m_LastModifyTime;
 477 }
 478
 479 int GitStatus::IsIgnore(const CString &gitdir, const CString &path, bool *isIgnore)
 480 {
 481         if(::g_IgnoreList.CheckIgnoreChanged(gitdir,path))
 482                 g_IgnoreList.LoadAllIgnoreFile(gitdir,path);
 483
 484          *isIgnore = g_IgnoreList.IsIgnore(path,gitdir);
 485
 486         return 0;
 487 }
 488
 489 static bool SortFileName(CGitFileName &Item1, CGitFileName &Item2)
 490 {
 491         return Item1.m_FileName.Compare(Item2.m_FileName)<0;
 492 }
 493
 494 int GitStatus::GetFileList(const CString &gitdir, const CString &subpath, std::vector<CGitFileName> &list)
 495 {
 496         WIN32_FIND_DATA data;
 497         HANDLE handle=::FindFirstFile(gitdir+_T("\\")+subpath+_T("\\*.*"), &data);
 498         do
 499         {
 500                 if(_tcscmp(data.cFileName, _T(".git")) == 0)
 501                         continue;
 502
 503                 if(_tcscmp(data.cFileName, _T(".")) == 0)
 504                         continue;
 505
 506                 if(_tcscmp(data.cFileName, _T("..")) == 0)
 507                         continue;
 508
 509                 CGitFileName filename;
 510
 511                 filename.m_CaseFileName = filename.m_FileName = data.cFileName;
 512                 filename.m_FileName.MakeLower();
 513
 514                 if(data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 515                 {
 516                         filename.m_FileName += _T('/');
 517                 }
 518
 519                 list.push_back(filename);
 520
 521         }while(::FindNextFile(handle, &data));
 522
 523         FindClose(handle);
 524
 525         std::sort(list.begin(), list.end(), SortFileName);
 526         return 0;
 527 }
 528
 529 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)
 530 {
 531         try
 532         {
 533                 CString path =subpath;
 534
 535                 path.Replace(_T('\\'),_T('/'));
 536                 if(!path.IsEmpty())
 537                         if(path[path.GetLength()-1] !=  _T('/'))
 538                                 path += _T('/'); //Add trail / to show it is directory, not file name.
 539
 540                 CString lowcasepath = path;
 541                 lowcasepath.MakeLower();
 542
 543                 std::vector<CGitFileName> filelist;
 544                 GetFileList(gitdir, subpath, filelist);
 545
 546                 if(status)
 547                 {
 548                         g_IndexFileMap.CheckAndUpdate(gitdir,true);
 549
 550                         g_HeadFileMap.CheckHeadAndUpdate(gitdir);
 551
 552                         SHARED_INDEX_PTR indexptr = g_IndexFileMap.SafeGet(gitdir);
 553                         SHARED_TREE_PTR treeptr = g_HeadFileMap.SafeGet(gitdir);
 554
 555                         std::vector<CGitFileName>::iterator it;
 556
 557                         // new git working tree has no index file
 558                         if (indexptr.get() == NULL)
 559                         {
 560                                 for (it = filelist.begin(); it < filelist.end(); ++it)
 561                                 {
 562                                         CString casepath = path + it->m_CaseFileName;
 563
 564                                         bool bIsDir = false;
 565                                         if (casepath.GetLength() > 0 && casepath[casepath.GetLength() - 1] == _T('/'))
 566                                                 bIsDir = true;
 567
 568                                         if (bIsDir) /*check if it is directory*/
 569                                         {
 570                                                 if (::PathFileExists(gitdir + casepath + _T("\\.git")))
 571                                                 { /* That is git submodule */
 572                                                         *status = git_wc_status_unknown;
 573                                                         if (callback)
 574                                                                 callback(gitdir + _T("/") + casepath, *status, bIsDir, pData, false, false);
 575                                                         continue;
 576                                                 }
 577                                         }
 578
 579                                         if (IsIgnore)
 580                                         {
 581                                                 if (g_IgnoreList.CheckIgnoreChanged(gitdir, casepath))
 582                                                         g_IgnoreList.LoadAllIgnoreFile(gitdir, casepath);
 583
 584                                                 if (g_IgnoreList.IsIgnore(casepath, gitdir))
 585                                                         *status = git_wc_status_ignored;
 586                                                 else if (bIsDir)
 587                                                         continue;
 588                                                 else
 589                                                         *status = git_wc_status_unversioned;
 590                                         }
 591                                         else if (bIsDir)
 592                                                 continue;
 593                                         else
 594                                                 *status = git_wc_status_unversioned;
 595
 596                                         if(callback)
 597                                                 callback(gitdir + _T("/") + casepath, *status, bIsDir, pData, false, false);
 598                                 }
 599                                 return 0;
 600                         }
 601
 602                         CString onepath;
 603                         CString casepath;
 604                         for (it = filelist.begin(); it < filelist.end(); ++it)
 605                         {
 606                                 casepath=onepath = path;
 607                                 onepath.MakeLower();
 608                                 onepath += it->m_FileName;
 609                                 casepath += it->m_CaseFileName;
 610
 611                                 LPTSTR onepathBuffer = onepath.GetBuffer();
 612                                 int pos = SearchInSortVector(*indexptr, onepathBuffer, onepath.GetLength());
 613                                 int posintree = SearchInSortVector(*treeptr, onepathBuffer, onepath.GetLength());
 614                                 onepath.ReleaseBuffer();
 615
 616                                 bool bIsDir =false;
 617                                 if(onepath.GetLength()>0 && onepath[onepath.GetLength()-1] == _T('/'))
 618                                         bIsDir =true;
 619
 620                                 if(pos <0 && posintree<0)
 621                                 {
 622                                         if(onepath.GetLength() ==0)
 623                                                 continue;
 624
 625                                         if(bIsDir) /*check if it is directory*/
 626                                         {
 627                                                 if(::PathFileExists(gitdir+onepath+_T("/.git")))
 628                                                 { /* That is git submodule */
 629                                                         *status = git_wc_status_unknown;
 630                                                         if(callback)
 631                                                                 callback(gitdir + _T("/") + casepath, *status, bIsDir, pData, false, false);
 632                                                         continue;
 633                                                 }
 634                                         }
 635
 636                                         if(!IsIgnore)
 637                                         {
 638                                                 *status = git_wc_status_unversioned;
 639                                                 if(callback)
 640                                                         callback(gitdir + _T("/") + casepath, *status, bIsDir, pData, false, false);
 641                                                 continue;
 642                                         }
 643
 644                                         if(::g_IgnoreList.CheckIgnoreChanged(gitdir,casepath))
 645                                                 g_IgnoreList.LoadAllIgnoreFile(gitdir,casepath);
 646
 647                                         if(g_IgnoreList.IsIgnore(casepath,gitdir))
 648                                                 *status = git_wc_status_ignored;
 649                                         else
 650                                                 *status = git_wc_status_unversioned;
 651
 652                                         if(callback)
 653                                                 callback(gitdir + _T("/") + casepath, *status, bIsDir, pData, false, false);
 654
 655                                 }
 656                                 else if(pos <0 && posintree>=0) /* check if file delete in index */
 657                                 {
 658                                         *status = git_wc_status_deleted;
 659                                         if(callback)
 660                                                 callback(gitdir + _T("/") + casepath, *status, bIsDir, pData, false, false);
 661
 662                                 }
 663                                 else if(pos >=0 && posintree <0) /* Check if file added */
 664                                 {
 665                                         *status = git_wc_status_added;
 666                                         if(callback)
 667                                                 callback(gitdir + _T("/") + casepath, *status, bIsDir, pData, false, false);
 668                                 }
 669                                 else
 670                                 {
 671                                         if(onepath.GetLength() ==0)
 672                                                 continue;
 673
 674                                         if(onepath[onepath.GetLength()-1] == _T('/'))
 675                                         {
 676                                                 *status = git_wc_status_normal;
 677                                                 if(callback)
 678                                                         callback(gitdir + _T("/") + casepath, *status, bIsDir, pData, false, false);
 679                                         }
 680                                         else
 681                                         {
 682                                                 bool assumeValid = false;
 683                                                 bool skipWorktree = false;
 684                                                 git_wc_status_kind filestatus;
 685                                                 GetFileStatus(gitdir, casepath, &filestatus, IsFul, IsRecursive, IsIgnore, callback, pData, &assumeValid, &skipWorktree);
 686                                         }
 687                                 }
 688
 689                         }/*End of For*/
 690
 691                         /* Check deleted file in system */
 692                         LPTSTR lowcasepathBuffer = lowcasepath.GetBuffer();
 693                         int start=0, end=0;
 694                         int pos=SearchInSortVector(*indexptr, lowcasepathBuffer, lowcasepath.GetLength());
 695
 696                         if (GetRangeInSortVector(*indexptr, lowcasepathBuffer, lowcasepath.GetLength(), &start, &end, pos) == 0)
 697                         {
 698                                 CGitIndexList::iterator it;
 699                                 CString oldstring;
 700
 701                                 for (it = indexptr->begin() + start; it <= indexptr->begin() + end; ++it)
 702                                 {
 703                                         int start = lowcasepath.GetLength();
 704                                         int index = (*it).m_FileName.Find(_T('/'), start);
 705                                         if(index<0)
 706                                                 index = (*it).m_FileName.GetLength();
 707
 708                                         CString filename = (*it).m_FileName.Mid(start, index-start);
 709                                         if(oldstring != filename)
 710                                         {
 711                                                 oldstring = filename;
 712                                                 if(SearchInSortVector(filelist, filename.GetBuffer(), filename.GetLength())<0)
 713                                                 {
 714                                                         *status = git_wc_status_deleted;
 715                                                         if(callback)
 716                                                                 callback(gitdir + _T("/") + filename, *status, false, pData, false, false);
 717                                                 }
 718                                         }
 719                                 }
 720                         }
 721
 722                         start = end =0;
 723                         pos=SearchInSortVector(*treeptr, lowcasepathBuffer, lowcasepath.GetLength());
 724                         if (GetRangeInSortVector(*treeptr, lowcasepathBuffer, lowcasepath.GetLength(), &start, &end, pos) == 0)
 725                         {
 726                                 CGitHeadFileList::iterator it;
 727                                 CString oldstring;
 728
 729                                 for (it = treeptr->begin() + start; it <= treeptr->begin() + end; ++it)
 730                                 {
 731                                         int start = lowcasepath.GetLength();
 732                                         int index = (*it).m_FileName.Find(_T('/'), start);
 733                                         if(index<0)
 734                                                 index = (*it).m_FileName.GetLength();
 735
 736                                         CString filename = (*it).m_FileName.Mid(start, index-start);
 737                                         if(oldstring != filename)
 738                                         {
 739                                                 oldstring = filename;
 740                                                 if(SearchInSortVector(filelist, filename.GetBuffer(), filename.GetLength())<0)
 741                                                 {
 742                                                         *status = git_wc_status_deleted;
 743                                                         if(callback)
 744                                                                 callback(gitdir + _T("/") + (*it).m_FileName, *status, false, pData, false, false);
 745                                                 }
 746                                         }
 747                                 }
 748                         }
 749                         lowcasepath.ReleaseBuffer();
 750
 751                 }/*End of if status*/
 752         }catch(...)
 753         {
 754                 return -1;
 755         }
 756         return 0;
 757
 758 }
 759 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)
 760 {
 761         try
 762         {
 763                 CString path =subpath;
 764
 765                 path.Replace(_T('\\'),_T('/'));
 766                 if(!path.IsEmpty())
 767                         if(path[path.GetLength()-1] !=  _T('/'))
 768                                 path += _T('/'); //Add trail / to show it is directory, not file name.
 769
 770                 CString lowcasepath = path;
 771                 lowcasepath.MakeLower();
 772
 773                 if(status)
 774                 {
 775                         g_IndexFileMap.CheckAndUpdate(gitdir, true);
 776
 777                         SHARED_INDEX_PTR indexptr = g_IndexFileMap.SafeGet(gitdir);
 778
 779                         if (indexptr == NULL)
 780                         {
 781                                 *status = git_wc_status_unversioned;
 782                                 return 0;
 783                         }
 784
 785                         int pos=SearchInSortVector(*indexptr,lowcasepath.GetBuffer(),lowcasepath.GetLength());
 786                         lowcasepath.ReleaseBuffer();
 787
 788                         //Not In Version Contorl
 789                         if(pos<0)
 790                         {
 791                                 if(!IsIgnore)
 792                                 {
 793                                         *status = git_wc_status_unversioned;
 794                                         if(callback)
 795                                                 callback(gitdir + _T("/") + path, *status, false, pData, false, false);
 796                                         return 0;
 797                                 }
 798                                 //Check ignore always.
 799                                 {
 800                                         if(::g_IgnoreList.CheckIgnoreChanged(gitdir,path))
 801                                                 g_IgnoreList.LoadAllIgnoreFile(gitdir,path);
 802
 803                                         if(g_IgnoreList.IsIgnore(path,gitdir))
 804                                                 *status = git_wc_status_ignored;
 805                                         else
 806                                                 *status = git_wc_status_unversioned;
 807
 808                                         g_HeadFileMap.CheckHeadAndUpdate(gitdir, false);
 809
 810                                         SHARED_TREE_PTR treeptr = g_HeadFileMap.SafeGet(gitdir);
 811                                         //Check init repository
 812                                         if (treeptr->HeadIsEmpty() && path.IsEmpty())
 813                                                 *status = git_wc_status_normal;
 814                                 }
 815
 816                         }
 817                         else  // In version control
 818                         {
 819                                 *status = git_wc_status_normal;
 820
 821                                 int start=0;
 822                                 int end=0;
 823                                 if(path.IsEmpty())
 824                                 {
 825                                         start=0;
 826                                         end = (int)indexptr->size() - 1;
 827                                 }
 828                                 LPTSTR lowcasepathBuffer = lowcasepath.GetBuffer();
 829                                 GetRangeInSortVector(*indexptr, lowcasepathBuffer, lowcasepath.GetLength(), &start, &end, pos);
 830                                 lowcasepath.ReleaseBuffer();
 831                                 CGitIndexList::iterator it;
 832
 833                                 it = indexptr->begin()+start;
 834
 835                                 // Check Conflict;
 836                                 for (int i = start; i <= end; ++i)
 837                                 {
 838                                         if (((*it).m_Flags & GIT_IDXENTRY_STAGEMASK) !=0)
 839                                         {
 840                                                 *status = git_wc_status_conflicted;
 841                                                 if(callback)
 842                                                 {
 843                                                         int dirpos = (*it).m_FileName.Find(_T('/'), path.GetLength());
 844                                                         if(dirpos<0 || IsRecursive)
 845                                                                 callback(gitdir + _T("\\") + it->m_FileName, git_wc_status_conflicted, false, pData, false, false);
 846                                                 }
 847                                                 else
 848                                                         break;
 849                                         }
 850                                         ++it;
 851                                 }
 852
 853                                 if( IsFul && (*status != git_wc_status_conflicted))
 854                                 {
 855                                         *status = git_wc_status_normal;
 856
 857                                         g_HeadFileMap.CheckHeadAndUpdate(gitdir);
 858
 859                                         //Check Add
 860                                         it = indexptr->begin()+start;
 861
 862
 863                                         {
 864                                                 //Check if new init repository
 865                                                 SHARED_TREE_PTR treeptr = g_HeadFileMap.SafeGet(gitdir);
 866
 867                                                 if (!treeptr->empty() || treeptr->HeadIsEmpty())
 868                                                 {
 869                                                         for (int i = start; i<= end; ++i)
 870                                                         {
 871                                                                 pos =SearchInSortVector(*treeptr, (*it).m_FileName.GetBuffer(), -1);
 872                                                                 (*it).m_FileName.ReleaseBuffer();
 873
 874                                                                 if(pos < 0)
 875                                                                 {
 876                                                                         *status = max(git_wc_status_added, *status); // added file found
 877                                                                         if(callback)
 878                                                                         {
 879                                                                                 int dirpos = (*it).m_FileName.Find(_T('/'), path.GetLength());
 880                                                                                 if(dirpos<0 || IsRecursive)
 881                                                                                         callback(gitdir + _T("\\") + it->m_FileName, git_wc_status_added, false, pData, false, false);
 882
 883                                                                         }
 884                                                                         else
 885                                                                                 break;
 886                                                                 }
 887
 888                                                                 if( pos>=0 && treeptr->at(pos).m_Hash != (*it).m_IndexHash)
 889                                                                 {
 890                                                                         *status = max(git_wc_status_modified, *status); // modified file found
 891                                                                         if(callback)
 892                                                                         {
 893                                                                                 int dirpos = (*it).m_FileName.Find(_T('/'), path.GetLength());
 894                                                                                 if(dirpos<0 || IsRecursive)
 895                                                                                         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);
 896
 897                                                                         }
 898                                                                         else
 899                                                                                 break;
 900                                                                 }
 901
 902                                                                 ++it;
 903                                                         }
 904
 905                                                         //Check Delete
 906                                                         if( *status == git_wc_status_normal )
 907                                                         {
 908                                                                 pos = SearchInSortVector(*treeptr, lowcasepathBuffer, lowcasepath.GetLength());
 909                                                                 if(pos <0)
 910                                                                 {
 911                                                                         *status = max(git_wc_status_added, *status); // added file found
 912
 913                                                                 }
 914                                                                 else
 915                                                                 {
 916                                                                         int hstart,hend;
 917                                                                         GetRangeInSortVector(*treeptr, lowcasepathBuffer, lowcasepath.GetLength(), &hstart, &hend, pos);
 918                                                                         CGitHeadFileList::iterator hit;
 919                                                                         hit = treeptr->begin() + hstart;
 920                                                                         CGitHeadFileList::iterator lastElement = treeptr->end();
 921                                                                         for (int i = hstart; i <= hend && hit != lastElement; ++i)
 922                                                                         {
 923                                                                                 if( SearchInSortVector(*indexptr,(*hit).m_FileName.GetBuffer(),-1) < 0)
 924                                                                                 {
 925                                                                                         (*hit).m_FileName.ReleaseBuffer();
 926                                                                                         *status = max(git_wc_status_deleted, *status); // deleted file found
 927                                                                                         break;
 928                                                                                 }
 929                                                                                 (*hit).m_FileName.ReleaseBuffer();
 930                                                                                 ++hit;
 931                                                                         }
 932                                                                 }
 933                                                         }
 934                                                 }
 935                                         }/* End lock*/
 936                                 }
 937                                 lowcasepath.ReleaseBuffer();
 938                                 // If define callback, it need update each file status.
 939                                 // If not define callback, status == git_wc_status_conflicted, needn't check each file status
 940                                 // because git_wc_status_conflicted is highest.s
 941                                 if(callback || (*status != git_wc_status_conflicted))
 942                                 {
 943                                         //Check File Time;
 944                                         //if(IsRecursive)
 945                                         {
 946                                                 CString sub, currentPath;
 947                                                 it = indexptr->begin()+start;
 948                                                 for (int i = start; i <= end; ++i, ++it)
 949                                                 {
 950                                                         if( !IsRecursive )
 951                                                         {
 952                                                                 //skip child directory
 953                                                                 int pos = (*it).m_FileName.Find(_T('/'), path.GetLength());
 954
 955                                                                 if( pos > 0)
 956                                                                 {
 957                                                                         currentPath = (*it).m_FileName.Left(pos);
 958                                                                         if( callback && (sub != currentPath) )
 959                                                                         {
 960                                                                                 sub = currentPath;
 961                                                                                 ATLTRACE(_T("index subdir %s\n"),sub);
 962                                                                                 if(callback) callback(gitdir + _T("\\") + sub,
 963                                                                                         git_wc_status_normal, true, pData, false, false);
 964                                                                         }
 965                                                                         continue;
 966                                                                 }
 967                                                         }
 968
 969                                                         git_wc_status_kind filestatus = git_wc_status_none;
 970                                                         bool assumeValid = false;
 971                                                         bool skipWorktree = false;
 972                                                         GetFileStatus(gitdir, (*it).m_FileName, &filestatus, IsFul, IsRecursive, IsIgnore, callback, pData, &assumeValid, &skipWorktree);
 973                                                 }
 974                                         }
 975                                 }
 976                         }
 977
 978                         if(callback) callback(gitdir + _T("/") + subpath, *status, true, pData, false, false);
 979                 }
 980
 981         }catch(...)
 982         {
 983                 if(status)
 984                         *status = git_wc_status_none;
 985                 return -1;
 986         }
 987
 988         return 0;
 989 }
 990
 991 bool GitStatus::IsExistIndexLockFile(const CString &gitdir)
 992 {
 993         CString sDirName= gitdir;
 994
 995         for (;;)
 996         {
 997                 if(PathFileExists(sDirName + _T("\\.git")))
 998                 {
 999                         if(PathFileExists(g_AdminDirMap.GetAdminDir(sDirName) + _T("index.lock")))
1000                                 return true;
1001                         else
1002                                 return false;
1003                 }
1004
1005                 int x = sDirName.ReverseFind(_T('\\'));
1006                 if (x < 2)
1007                         return false;
1008
1009                 sDirName = sDirName.Left(x);
1010         }
1011 }