src/Git/GitStatus.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008-2017 - 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 #include "SysInfo.h"
  29 #include "SmartHandle.h"
  30
  31 extern CGitAdminDirMap g_AdminDirMap;
  32 CGitIndexFileMap g_IndexFileMap;
  33 CGitHeadFileMap g_HeadFileMap;
  34 CGitIgnoreList  g_IgnoreList;
  35
  36 GitStatus::GitStatus()
  37         : status(nullptr)
  38 {
  39         m_status.assumeValid = m_status.skipWorktree = false;
  40         m_status.status = git_wc_status_none;
  41 }
  42
  43 // static method
  44 #ifndef TGITCACHE
  45 int GitStatus::GetAllStatus(const CTGitPath& path, bool bIsRecursive, git_wc_status2_t& status)
  46 {
  47         BOOL                                            isDir;
  48         CString                                         sProjectRoot;
  49
  50         isDir = path.IsDirectory();
  51         if (!path.HasAdminDir(&sProjectRoot))
  52                 return git_wc_status_none;
  53
  54         CString sSubPath;
  55         CString s = path.GetWinPathString();
  56         if (s.GetLength() > sProjectRoot.GetLength())
  57         {
  58                 if (sProjectRoot.GetLength() == 3 && sProjectRoot[1] == L':')
  59                         sSubPath = s.Right(s.GetLength() - sProjectRoot.GetLength());
  60                 else
  61                         sSubPath = s.Right(s.GetLength() - sProjectRoot.GetLength() - 1/*otherwise it gets initial slash*/);
  62         }
  63
  64         bool isfull = ((DWORD)CRegStdDWORD(L"Software\\TortoiseGit\\CacheType",
  65                                 GetSystemMetrics(SM_REMOTESESSION) ? ShellCache::dll : ShellCache::exe) == ShellCache::dllFull);
  66
  67         if(isDir)
  68         {
  69                 auto err = GetDirStatus(sProjectRoot, sSubPath, &status.status, isfull, bIsRecursive, isfull);
  70                 AdjustFolderStatus(status.status);
  71                 return err;
  72         }
  73
  74         return GetFileStatus(sProjectRoot, sSubPath, status, isfull, isfull);
  75 }
  76 #endif
  77
  78 // static method
  79 git_wc_status_kind GitStatus::GetMoreImportant(git_wc_status_kind status1, git_wc_status_kind status2)
  80 {
  81         if (GetStatusRanking(status1) >= GetStatusRanking(status2))
  82                 return status1;
  83         return status2;
  84 }
  85 // static private method
  86 int GitStatus::GetStatusRanking(git_wc_status_kind status)
  87 {
  88         switch (status)
  89         {
  90                 case git_wc_status_none:
  91                         return 0;
  92                 case git_wc_status_unversioned:
  93                         return 1;
  94                 case git_wc_status_ignored:
  95                         return 2;
  96                 case git_wc_status_normal:
  97                 case git_wc_status_added:
  98                         return 6;
  99                 case git_wc_status_deleted:
 100                         return 8;
 101                 case git_wc_status_modified:
 102                         return 10;
 103                 case git_wc_status_conflicted:
 104                         return 12;
 105         }
 106         return 0;
 107 }
 108
 109 #ifndef TGITCACHE
 110 void GitStatus::GetStatus(const CTGitPath& path, bool /*update*/ /* = false */, bool noignore /* = false */, bool /*noexternals*/ /* = false */)
 111 {
 112         // NOTE: unlike the SVN version this one does not cache the enumerated files, because in practice no code in all of
 113         //       Tortoise uses this, all places that call GetStatus create a temp GitStatus object which gets destroyed right
 114         //       after the call again
 115
 116         CString sProjectRoot;
 117         if ( !path.HasAdminDir(&sProjectRoot) )
 118                 return;
 119
 120         bool isfull = ((DWORD)CRegStdDWORD(L"Software\\TortoiseGit\\CacheType",
 121                                 GetSystemMetrics(SM_REMOTESESSION) ? ShellCache::dll : ShellCache::exe) == ShellCache::dllFull);
 122
 123         int err = 0;
 124
 125         LPCTSTR lpszSubPath = nullptr;
 126         CString sSubPath;
 127         CString s = path.GetWinPathString();
 128         if (s.GetLength() > sProjectRoot.GetLength())
 129         {
 130                 sSubPath = s.Right(s.GetLength() - sProjectRoot.GetLength());
 131                 lpszSubPath = sSubPath;
 132                 // skip initial slash if necessary
 133                 if (*lpszSubPath == L'\\')
 134                         ++lpszSubPath;
 135         }
 136
 137         m_status.status = git_wc_status_none;
 138         m_status.assumeValid = false;
 139         m_status.skipWorktree = false;
 140
 141         if (path.IsDirectory())
 142         {
 143                 err = GetDirStatus(sProjectRoot, lpszSubPath, &m_status.status, isfull, false, !noignore);
 144                 AdjustFolderStatus(m_status.status);
 145         }
 146         else
 147                 err = GetFileStatus(sProjectRoot, lpszSubPath, m_status, isfull, !noignore);
 148
 149         // Error present if function is not under version control
 150         if (err)
 151         {
 152                 status = nullptr;
 153                 return;
 154         }
 155
 156         status = &m_status;
 157 }
 158 #endif
 159
 160 typedef CComCritSecLock<CComCriticalSection> CAutoLocker;
 161
 162 int GitStatus::GetFileStatus(const CString& gitdir, CString path, git_wc_status2_t& status, BOOL IsFull, BOOL IsIgnore, bool update)
 163 {
 164         ATLASSERT(!status.assumeValid && !status.skipWorktree);
 165
 166         path.Replace(L'\\', L'/');
 167
 168         if (update)
 169                 g_IndexFileMap.CheckAndUpdate(gitdir);
 170         auto pIndex = g_IndexFileMap.SafeGet(gitdir);
 171         CGitHash hash;
 172         if (!pIndex || pIndex->GetFileStatus(gitdir, path, status, &hash))
 173         {
 174                 // git working tree has broken index or an error occurred in GetFileStatus
 175                 status.status = git_wc_status_none;
 176                 return -1;
 177         }
 178
 179         if (status.status == git_wc_status_conflicted)
 180                 return 0;
 181
 182         if (status.status == git_wc_status_unversioned)
 183         {
 184                 if (IsFull)
 185                 {
 186                         if (update)
 187                                 g_HeadFileMap.CheckHeadAndUpdate(gitdir);
 188
 189                         // Check Head Tree Hash
 190                         SHARED_TREE_PTR treeptr = g_HeadFileMap.SafeGet(gitdir);
 191                         // broken HEAD
 192                         if (!treeptr)
 193                         {
 194                                 status.status = git_wc_status_none;
 195                                 return -1;
 196                         }
 197
 198                         // deleted only in index item?
 199                         if (SearchInSortVector(*treeptr, path, -1) != NPOS)
 200                         {
 201                                 status.status = git_wc_status_deleted;
 202                                 return 0;
 203                         }
 204                 }
 205
 206                 if (!IsIgnore)
 207                 {
 208                         status.status = git_wc_status_unversioned;
 209                         return 0;
 210                 }
 211
 212                 g_IgnoreList.CheckAndUpdateIgnoreFiles(gitdir, path, false);
 213                 if (g_IgnoreList.IsIgnore(path, gitdir, false))
 214                         status.status = git_wc_status_ignored;
 215
 216                 return 0;
 217         }
 218
 219         if ((status.status == git_wc_status_normal || status.status == git_wc_status_modified) && IsFull)
 220         {
 221                 if (update)
 222                         g_HeadFileMap.CheckHeadAndUpdate(gitdir);
 223
 224                 // Check Head Tree Hash
 225                 SHARED_TREE_PTR treeptr = g_HeadFileMap.SafeGet(gitdir);
 226                 // broken HEAD
 227                 if (!treeptr)
 228                 {
 229                         status.status = git_wc_status_none;
 230                         return -1;
 231                 }
 232
 233                 //add item
 234                 size_t start = SearchInSortVector(*treeptr, path, -1);
 235                 if (start == NPOS)
 236                 {
 237                         status.status = git_wc_status_added;
 238                         CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) L": File miss in head tree %s", (LPCTSTR)path);
 239                         return 0;
 240                 }
 241
 242                 // staged and not commit
 243                 if (!status.assumeValid && !status.skipWorktree && (*treeptr)[start].m_Hash != hash)
 244                 {
 245                         status.status = git_wc_status_modified;
 246                         return 0;
 247                 }
 248         }
 249
 250         return 0;
 251 }
 252
 253 // checks whether indexPath is a direct submodule and not one in a subfolder
 254 static bool IsDirectSubmodule(const CString& indexPath, int prefix)
 255 {
 256         if (!CStringUtils::EndsWith(indexPath, L'/'))
 257                 return false;
 258
 259         auto ptr = indexPath.GetString() + prefix;
 260         int folderdepth = 0;
 261         while (*ptr)
 262         {
 263                 if (*ptr == L'/')
 264                         ++folderdepth;
 265                 ++ptr;
 266         }
 267
 268         return folderdepth == 1;
 269 }
 270
 271 #ifdef TGITCACHE
 272 bool GitStatus::CheckAndUpdateIgnoreFiles(const CString& gitdir, const CString& subpaths, bool isDir)
 273 {
 274         return g_IgnoreList.CheckAndUpdateIgnoreFiles(gitdir, subpaths, isDir);
 275 }
 276
 277 bool GitStatus::IsIgnored(const CString& gitdir, const CString& path, bool isDir)
 278 {
 279         return g_IgnoreList.IsIgnore(path, gitdir, isDir);
 280 }
 281
 282 int GitStatus::GetFileList(CString path, std::vector<CGitFileName>& list, bool& isRepoRoot)
 283 {
 284         path += L"\\*.*";
 285         WIN32_FIND_DATA data;
 286         CAutoFindFile handle = ::FindFirstFileEx(path, FindExInfoBasic, &data, FindExSearchNameMatch, nullptr, FIND_FIRST_EX_LARGE_FETCH);
 287         if (!handle)
 288                 return -1;
 289         do
 290         {
 291                 if (wcscmp(data.cFileName, L".git") == 0)
 292                 {
 293                         isRepoRoot = true;
 294                         continue;
 295                 }
 296
 297                 if (wcscmp(data.cFileName, L".") == 0)
 298                         continue;
 299
 300                 if (wcscmp(data.cFileName, L"..") == 0)
 301                         continue;
 302
 303                 CGitFileName filename(data.cFileName, ((__int64)data.nFileSizeHigh << 32) + data.nFileSizeLow, ((__int64)data.ftLastWriteTime.dwHighDateTime << 32) + data.ftLastWriteTime.dwLowDateTime);
 304                 if(data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 305                         filename.m_FileName += L'/';
 306
 307                 list.push_back(filename);
 308
 309         }while(::FindNextFile(handle, &data));
 310
 311         handle.CloseHandle(); // manually close handle here in order to keep handles open as short as possible
 312
 313         std::sort(list.begin(), list.end(), SortCGitFileName);
 314         return 0;
 315 }
 316
 317 int GitStatus::EnumDirStatus(const CString& gitdir, const CString& subpath, git_wc_status_kind* dirstatus, FILL_STATUS_CALLBACK callback, void* pData)
 318 {
 319         CString path = subpath;
 320
 321         path.Replace(L'\\', L'/');
 322         if (!path.IsEmpty() && path[path.GetLength() - 1] != L'/')
 323                 path += L'/'; // Add trail / to show it is directory, not file name.
 324
 325         std::vector<CGitFileName> filelist;
 326         bool isRepoRoot = false;
 327         GetFileList(CombinePath(gitdir, subpath), filelist, isRepoRoot);
 328         *dirstatus = git_wc_status_unknown;
 329         if (isRepoRoot)
 330                 *dirstatus = git_wc_status_normal;
 331
 332         g_IndexFileMap.CheckAndUpdate(gitdir);
 333
 334         g_HeadFileMap.CheckHeadAndUpdate(gitdir);
 335
 336         SHARED_INDEX_PTR indexptr = g_IndexFileMap.SafeGet(gitdir);
 337         SHARED_TREE_PTR treeptr = g_HeadFileMap.SafeGet(gitdir);
 338
 339         // there was an error loading the index or the HEAD commit/tree
 340         if (!indexptr || !treeptr)
 341                 return -1;
 342
 343         CAutoRepository repository;
 344         for (auto it = filelist.cbegin(), itend = filelist.cend(); it != itend; ++it)
 345         {
 346                 auto& fileentry = *it;
 347
 348                 CString onepath(path);
 349                 onepath += fileentry.m_FileName;
 350
 351                 bool bIsDir = false;
 352                 if (!onepath.IsEmpty() && onepath[onepath.GetLength() - 1] == L'/')
 353                         bIsDir = true;
 354
 355                 int matchLength = -1;
 356                 if (bIsDir)
 357                         matchLength = onepath.GetLength();
 358                 size_t pos = SearchInSortVector(*indexptr, onepath, matchLength);
 359                 size_t posintree = SearchInSortVector(*treeptr, onepath, matchLength);
 360
 361                 git_wc_status2_t status = { git_wc_status_none, false, false };
 362
 363                 if (pos == NPOS && posintree == NPOS)
 364                 {
 365                         status.status = git_wc_status_unversioned;
 366
 367                         g_IgnoreList.CheckAndUpdateIgnoreFiles(gitdir, onepath, bIsDir);
 368                         if (g_IgnoreList.IsIgnore(onepath, gitdir, bIsDir))
 369                                 status.status = git_wc_status_ignored;
 370
 371                         callback(CombinePath(gitdir, onepath), &status, bIsDir, fileentry.m_LastModified, pData);
 372                 }
 373                 else if (pos == NPOS && posintree != NPOS) /* check if file delete in index */
 374                 {
 375                         status.status = git_wc_status_deleted;
 376                         callback(CombinePath(gitdir, onepath), &status, bIsDir, fileentry.m_LastModified, pData);
 377                 }
 378                 else if (pos != NPOS && posintree == NPOS) /* Check if file added */
 379                 {
 380                         status.status = git_wc_status_added;
 381                         if ((*indexptr)[pos].m_Flags & GIT_IDXENTRY_STAGEMASK)
 382                                 status.status = git_wc_status_conflicted;
 383                         callback(CombinePath(gitdir, onepath), &status, bIsDir, fileentry.m_LastModified, pData);
 384                 }
 385                 else
 386                 {
 387                         if (bIsDir)
 388                         {
 389                                 status.status = git_wc_status_normal;
 390                                 callback(CombinePath(gitdir, onepath), &status, bIsDir, fileentry.m_LastModified, pData);
 391                         }
 392                         else
 393                         {
 394                                 auto& indexentry = (*indexptr)[pos];
 395                                 if (indexentry.m_Flags & GIT_IDXENTRY_STAGEMASK)
 396                                 {
 397                                         status.status = git_wc_status_conflicted;
 398                                         callback(CombinePath(gitdir, onepath), &status, false, fileentry.m_LastModified, pData);
 399                                         continue;
 400                                 }
 401                                 if ((*indexptr).GetFileStatus(repository, gitdir, indexentry, status, CGit::filetime_to_time_t(fileentry.m_LastModified), fileentry.m_Size))
 402                                         return -1;
 403                                 if (status.status == git_wc_status_normal && !status.assumeValid && !status.skipWorktree && (*treeptr)[posintree].m_Hash != indexentry.m_IndexHash)
 404                                         status.status = git_wc_status_modified;
 405                                 callback(CombinePath(gitdir, onepath), &status, false, fileentry.m_LastModified, pData);
 406                         }
 407                 }
 408         }/*End of For*/
 409         repository.Free(); // explicitly free the handle here in order to keep an open repository as short as possible
 410
 411         /* Check deleted file in system */
 412         size_t start = 0, end = 0;
 413         size_t pos = SearchInSortVector(*indexptr, path, path.GetLength()); // match path prefix, (sub)folders end with slash
 414         std::set<CString> alreadyReported;
 415
 416         if (GetRangeInSortVector(*indexptr, path, path.GetLength(), &start, &end, pos) == 0)
 417         {
 418                 *dirstatus = git_wc_status_normal; // here we know that this folder has versioned entries
 419                 CString oldstring;
 420                 for (auto it = indexptr->cbegin() + start, itlast = indexptr->cbegin() + end; it <= itlast; ++it)
 421                 {
 422                         auto& entry = *it;
 423                         int commonPrefixLength = path.GetLength();
 424                         int index = entry.m_FileName.Find(L'/', commonPrefixLength);
 425                         if (index < 0)
 426                                 index = entry.m_FileName.GetLength();
 427                         else
 428                                 ++index; // include slash at the end for subfolders, so that we do not match files by mistake
 429
 430                         CString filename = entry.m_FileName.Mid(commonPrefixLength, index - commonPrefixLength);
 431                         if (oldstring != filename)
 432                         {
 433                                 oldstring = filename;
 434                                 int length = filename.GetLength();
 435                                 bool isDir = filename[length - 1] == L'/';
 436                                 if (SearchInSortVector(filelist, filename, isDir ? length : -1) == NPOS) // do full match for filenames and only prefix-match ending with "/" for folders
 437                                 {
 438                                         git_wc_status2_t status = { (!isDir || IsDirectSubmodule(entry.m_FileName, commonPrefixLength)) ? git_wc_status_deleted : git_wc_status_modified, false, false }; // only report deleted submodules and files as deletedy
 439                                         if ((entry.m_FlagsExtended & GIT_IDXENTRY_SKIP_WORKTREE) != 0)
 440                                         {
 441                                                 status.skipWorktree = true;
 442                                                 status.status = git_wc_status_normal;
 443                                                 oldstring.Empty(); // without this a deleted folder which has two versioned files and only the first is skipwoktree flagged gets reported as normal
 444                                                 if (alreadyReported.find(filename) != alreadyReported.cend())
 445                                                         continue;
 446                                         }
 447                                         alreadyReported.insert(filename);
 448                                         callback(CombinePath(gitdir, subpath, filename), &status, isDir, 0, pData);
 449                                 }
 450                         }
 451                 }
 452         }
 453
 454         start = end = 0;
 455         pos = SearchInSortVector(*treeptr, path, path.GetLength()); // match path prefix, (sub)folders end with slash
 456         if (GetRangeInSortVector(*treeptr, path, path.GetLength(), &start, &end, pos) == 0)
 457         {
 458                 *dirstatus = git_wc_status_normal; // here we know that this folder has versioned entries
 459                 CString oldstring;
 460                 for (auto it = treeptr->cbegin() + start, itlast = treeptr->cbegin() + end; it <= itlast; ++it)
 461                 {
 462                         auto& entry = *it;
 463                         int commonPrefixLength = path.GetLength();
 464                         int index = entry.m_FileName.Find(L'/', commonPrefixLength);
 465                         if (index < 0)
 466                                 index = entry.m_FileName.GetLength();
 467                         else
 468                                 ++index; // include slash at the end for subfolders, so that we do not match files by mistake
 469
 470                         CString filename = entry.m_FileName.Mid(commonPrefixLength, index - commonPrefixLength);
 471                         if (oldstring != filename && alreadyReported.find(filename) == alreadyReported.cend())
 472                         {
 473                                 oldstring = filename;
 474                                 int length = filename.GetLength();
 475                                 bool isDir = filename[length - 1] == L'/';
 476                                 if (SearchInSortVector(filelist, filename, isDir ? length : -1) == NPOS) // do full match for filenames and only prefix-match ending with "/" for folders
 477                                 {
 478                                         git_wc_status2_t status = { (!isDir || IsDirectSubmodule(entry.m_FileName, commonPrefixLength)) ? git_wc_status_deleted : git_wc_status_modified, false, false };
 479                                         callback(CombinePath(gitdir, subpath, filename), &status, isDir, 0, pData);
 480                                 }
 481                         }
 482                 }
 483         }
 484         return 0;
 485 }
 486 #endif
 487
 488 #ifndef TGITCACHE
 489 int GitStatus::GetDirStatus(const CString& gitdir, const CString& subpath, git_wc_status_kind* status, BOOL IsFul, BOOL IsRecursive, BOOL IsIgnore)
 490 {
 491         ATLASSERT(status);
 492
 493         CString path = subpath;
 494
 495         path.Replace(L'\\', L'/');
 496         if (!path.IsEmpty() && path[path.GetLength() - 1] != L'/')
 497                 path += L'/'; //Add trail / to show it is directory, not file name.
 498
 499         g_IndexFileMap.CheckAndUpdate(gitdir);
 500
 501         SHARED_INDEX_PTR indexptr = g_IndexFileMap.SafeGet(gitdir);
 502
 503         // broken index
 504         if (!indexptr)
 505         {
 506                 *status = git_wc_status_none;
 507                 return -1;
 508         }
 509
 510         size_t pos = SearchInSortVector(*indexptr, path, path.GetLength());
 511
 512         // Not In Version Contorl
 513         if (pos == NPOS)
 514         {
 515                 if (!IsIgnore)
 516                 {
 517                         // WC root is at least normal if there are no files added/deleted
 518                         if (subpath.IsEmpty())
 519                         {
 520                                 *status = git_wc_status_normal;
 521                                 return 0;
 522                         }
 523                         *status = git_wc_status_unversioned;
 524                         return 0;
 525                 }
 526
 527                 g_HeadFileMap.CheckHeadAndUpdate(gitdir);
 528
 529                 SHARED_TREE_PTR treeptr = g_HeadFileMap.SafeGet(gitdir);
 530                 // broken HEAD
 531                 if (!treeptr)
 532                 {
 533                         *status = git_wc_status_none;
 534                         return -1;
 535                 }
 536
 537                 // check whether there files in head with are not in index
 538                 pos = SearchInSortVector(*treeptr, path, path.GetLength());
 539                 if (pos != NPOS)
 540                 {
 541                         *status = git_wc_status_deleted;
 542                         return 0;
 543                 }
 544
 545                 // WC root is at least normal if there are no files added/deleted
 546                 if (path.IsEmpty())
 547                 {
 548                         *status = git_wc_status_normal;
 549                         return 0;
 550                 }
 551
 552                 // Check ignore
 553                 g_IgnoreList.CheckAndUpdateIgnoreFiles(gitdir, path, true);
 554                 if (g_IgnoreList.IsIgnore(path, gitdir, true))
 555                         *status = git_wc_status_ignored;
 556                 else
 557                         *status = git_wc_status_unversioned;
 558
 559                 return 0;
 560         }
 561
 562         // In version control
 563         *status = git_wc_status_normal;
 564
 565         size_t start = 0;
 566         size_t end = 0;
 567
 568         GetRangeInSortVector(*indexptr, path, path.GetLength(), &start, &end, pos);
 569
 570         // Check Conflict;
 571         for (auto it = indexptr->cbegin() + start, itlast = indexptr->cbegin() + end; indexptr->m_bHasConflicts && it <= itlast; ++it)
 572         {
 573                 if (((*it).m_Flags & GIT_IDXENTRY_STAGEMASK) != 0)
 574                 {
 575                         *status = git_wc_status_conflicted;
 576                         // When status == git_wc_status_conflicted, we don't need to check each file status
 577                         // because git_wc_status_conflicted is the highest.
 578                         return 0;
 579                 }
 580         }
 581
 582         if (IsFul)
 583         {
 584                 g_HeadFileMap.CheckHeadAndUpdate(gitdir);
 585
 586                 // Check Add
 587                 {
 588                         // Check if new init repository
 589                         SHARED_TREE_PTR treeptr = g_HeadFileMap.SafeGet(gitdir);
 590                         // broken HEAD
 591                         if (!treeptr)
 592                         {
 593                                 *status = git_wc_status_none;
 594                                 return -1;
 595                         }
 596
 597                         {
 598                                 for (auto it = indexptr->cbegin() + start, itlast = indexptr->cbegin() + end; it <= itlast; ++it)
 599                                 {
 600                                         auto& indexentry = *it;
 601                                         pos = SearchInSortVector(*treeptr, indexentry.m_FileName, -1);
 602
 603                                         if (pos == NPOS)
 604                                         {
 605                                                 *status = GetMoreImportant(git_wc_status_added, *status); // added file found
 606                                                 AdjustFolderStatus(*status);
 607                                                 if (GetMoreImportant(*status, git_wc_status_modified) == *status) // the only potential higher status which me might get in this loop
 608                                                         break;
 609                                                 continue;
 610                                         }
 611
 612                                         if ((indexentry.m_Flags & GIT_IDXENTRY_VALID) == 0 && (indexentry.m_FlagsExtended & GIT_IDXENTRY_SKIP_WORKTREE) == 0 && (*treeptr)[pos].m_Hash != indexentry.m_IndexHash)
 613                                         {
 614                                                 *status = GetMoreImportant(git_wc_status_modified, *status); // modified file found
 615                                                 break;
 616                                         }
 617                                 }
 618
 619                                 // Check Delete
 620                                 if (*status == git_wc_status_normal)
 621                                 {
 622                                         pos = SearchInSortVector(*treeptr, path, path.GetLength());
 623                                         if (pos == NPOS)
 624                                                 *status = GetMoreImportant(git_wc_status_added, *status); // added file found
 625                                         else
 626                                         {
 627                                                 size_t hstart, hend;
 628                                                 // we know that pos exists in treeptr
 629                                                 GetRangeInSortVector(*treeptr, path, path.GetLength(), &hstart, &hend, pos);
 630                                                 for (auto hit = treeptr->cbegin() + hstart, lastElement = treeptr->cbegin() + hend; hit <= lastElement; ++hit)
 631                                                 {
 632                                                         if (SearchInSortVector(*indexptr, (*hit).m_FileName, -1) == NPOS)
 633                                                         {
 634                                                                 *status = GetMoreImportant(git_wc_status_deleted, *status); // deleted file found
 635                                                                 break;
 636                                                         }
 637                                                 }
 638                                         }
 639                                 }
 640                         }
 641                 } /* End lock*/
 642         }
 643
 644         auto mostImportantPossibleFolderStatus = GetMoreImportant(git_wc_status_added, GetMoreImportant(git_wc_status_modified, git_wc_status_deleted));
 645         AdjustFolderStatus(mostImportantPossibleFolderStatus);
 646         // we can skip here when we already have the highest possible status
 647         if (mostImportantPossibleFolderStatus == *status)
 648                 return 0;
 649
 650         for (auto it = indexptr->cbegin() + start, itlast = indexptr->cbegin() + end; it <= itlast; ++it)
 651         {
 652                 auto& indexentry = *it;
 653                 // skip child directory, but handle submodules
 654                 if (!IsRecursive && indexentry.m_FileName.Find(L'/', path.GetLength()) > 0 && !IsDirectSubmodule(indexentry.m_FileName, path.GetLength()))
 655                         continue;
 656
 657                 git_wc_status2_t filestatus = { git_wc_status_none, false, false };
 658                 GetFileStatus(gitdir, indexentry.m_FileName, filestatus, IsFul, IsIgnore, false);
 659                 switch (filestatus.status)
 660                 {
 661                 case git_wc_status_added:
 662                 case git_wc_status_modified:
 663                 case git_wc_status_deleted:
 664                 //case git_wc_status_conflicted: cannot happen, we exit as soon we found a conflict in subpath
 665                         *status = GetMoreImportant(filestatus.status, *status);
 666                         AdjustFolderStatus(*status);
 667                         if (mostImportantPossibleFolderStatus == *status)
 668                                 return 0;
 669                 }
 670         }
 671
 672         return 0;
 673 }
 674 #endif
 675
 676 #ifdef TGITCACHE
 677 bool GitStatus::IsExistIndexLockFile(CString sDirName)
 678 {
 679         if (!PathIsDirectory(sDirName))
 680         {
 681                 int x = sDirName.ReverseFind(L'\\');
 682                 if (x < 2)
 683                         return false;
 684
 685                 sDirName.Truncate(x);
 686         }
 687
 688         for (;;)
 689         {
 690                 if (PathFileExists(CombinePath(sDirName, L".git")))
 691                 {
 692                         if (PathFileExists(g_AdminDirMap.GetWorktreeAdminDirConcat(sDirName, L"index.lock")))
 693                                 return true;
 694
 695                         return false;
 696                 }
 697
 698                 int x = sDirName.ReverseFind(L'\\');
 699                 if (x < 2)
 700                         return false;
 701
 702                 sDirName.Truncate(x);
 703         }
 704 }
 705 #endif
 706
 707 bool GitStatus::ReleasePath(const CString &gitdir)
 708 {
 709         g_IndexFileMap.SafeClear(gitdir);
 710         g_HeadFileMap.SafeClear(gitdir);
 711         return true;
 712 }
 713
 714 bool GitStatus::ReleasePathsRecursively(const CString &rootpath)
 715 {
 716         g_IndexFileMap.SafeClearRecursively(rootpath);
 717         g_HeadFileMap.SafeClearRecursively(rootpath);
 718         return true;
 719 }
 720
 721 void GitStatus::AdjustFolderStatus(git_wc_status_kind& status)
 722 {
 723         if (status == git_wc_status_deleted || status == git_wc_status_added)
 724                 status = git_wc_status_modified;
 725 }