?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
use gitdll gethash and clean up some warning
[TortoiseGit.git] / src / Git / GitStatus.cpp
blob3356144968866845ef3b665dda66a7eccc6663fe
1 // TortoiseGit - a Windows shell extension for easy version control
2
3 // Copyright (C) 2003-2008 - 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 #ifdef _TORTOISESHELL
22 #include "ShellExt.h"
23 #else
24 #include "registry.h"
25 #endif
26 //#include "resource.h"
27 #include "..\TortoiseShell\resource.h"
28 //#include "git_config.h"
29 #include "GitStatus.h"
30 #include "UnicodeUtils.h"
31 //#include "GitGlobal.h"
32 //#include "GitHelpers.h"
33 #ifdef _MFC_VER
34 //# include "Git.h"
35 //# include "MessageBox.h"
36 //# include "registry.h"
37 //# include "TGitPath.h"
38 //# include "PathUtils.h"
39 #endif
40 #include "git.h"
41 #include "gitindex.h"
42 #include "shellcache.h"
43
44 CGitIndexFileMap g_IndexFileMap;
45 CGitHeadFileMap g_HeadFileMap;
46 CGitIgnoreList g_IgnoreList;
47
48 GitStatus::GitStatus(bool * pbCanceled)
49 : status(NULL)
50 {
51 #if 0
52 m_pool = git_pool_create (NULL);
53
54 git_error_clear(git_client_create_context(&ctx, m_pool));
55
56 if (pbCanceled)
57 {
58 ctx->cancel_func = cancel;
59 ctx->cancel_baton = pbCanceled;
60 }
61
62 #ifdef _MFC_VER
63 git_error_clear(git_config_ensure(NULL, m_pool));
64
65 // set up authentication
66 m_prompt.Init(m_pool, ctx);
67
68 // set up the configuration
69 m_err = git_config_get_config (&(ctx->config), g_pConfigDir, m_pool);
70
71 if (m_err)
72 {
73 ::MessageBox(NULL, this->GetLastErrorMsg(), _T("TortoiseGit"), MB_ICONERROR);
74 git_error_clear(m_err);
75 git_pool_destroy (m_pool); // free the allocated memory
76 exit(-1);
77 }
78
79 // set up the Git_SSH param
80 CString tgit_ssh = CRegString(_T("Software\\TortoiseGit\\SSH"));
81 if (tgit_ssh.IsEmpty())
82 tgit_ssh = CPathUtils::GetAppDirectory() + _T("TortoisePlink.exe");
83 tgit_ssh.Replace('\\', '/');
84 if (!tgit_ssh.IsEmpty())
85 {
86 git_config_t * cfg = (git_config_t *)apr_hash_get ((apr_hash_t *)ctx->config, Git_CONFIG_CATEGORY_CONFIG,
87 APR_HASH_KEY_STRING);
88 git_config_set(cfg, Git_CONFIG_SECTION_TUNNELS, "ssh", CUnicodeUtils::GetUTF8(tgit_ssh));
89 }
90 #else
91 git_error_clear(git_config_ensure(NULL, m_pool));
92
93 // set up the configuration
94 m_err = git_config_get_config (&(ctx->config), g_pConfigDir, m_pool);
95
96 #endif
97 #endif
98 }
99
100 GitStatus::~GitStatus(void)
101 {
102 #if 0
103 git_error_clear(m_err);
104 git_pool_destroy (m_pool); // free the allocated memory
105 #endif
106 }
107
108 void GitStatus::ClearPool()
109 {
110 #if 0
111 git_pool_clear(m_pool);
112 #endif
113 }
114
115 #ifdef _MFC_VER
116 CString GitStatus::GetLastErrorMsg() const
117 {
118 // return Git::GetErrorString(m_err);
119 return CString("");
120 }
121 #else
122 stdstring GitStatus::GetLastErrorMsg() const
123 {
124
125 stdstring msg;
126 #if 0
127 char errbuf[256];
128
129 if (m_err != NULL)
130 {
131 git_error_t * ErrPtr = m_err;
132 if (ErrPtr->message)
133 {
134 msg = CUnicodeUtils::StdGetUnicode(ErrPtr->message);
135 }
136 else
137 {
138 /* Is this a Subversion-specific error code? */
139 if ((ErrPtr->apr_err > APR_OS_START_USEERR)
140 && (ErrPtr->apr_err <= APR_OS_START_CANONERR))
141 msg = CUnicodeUtils::StdGetUnicode(git_strerror (ErrPtr->apr_err, errbuf, sizeof (errbuf)));
142 /* Otherwise, this must be an APR error code. */
143 else
144 {
145 git_error_t *temp_err = NULL;
146 const char * err_string = NULL;
147 temp_err = git_utf_cstring_to_utf8(&err_string, apr_strerror (ErrPtr->apr_err, errbuf, sizeof (errbuf)-1), ErrPtr->pool);
148 if (temp_err)
149 {
150 git_error_clear (temp_err);
151 msg = _T("Can't recode error string from APR");
152 }
153 else
154 {
155 msg = CUnicodeUtils::StdGetUnicode(err_string);
156 }
157 }
158
159 }
160
161 while (ErrPtr->child)
162 {
163 ErrPtr = ErrPtr->child;
164 msg += _T("\n");
165 if (ErrPtr->message)
166 {
167 msg += CUnicodeUtils::StdGetUnicode(ErrPtr->message);
168 }
169 else
170 {
171 /* Is this a Subversion-specific error code? */
172 if ((ErrPtr->apr_err > APR_OS_START_USEERR)
173 && (ErrPtr->apr_err <= APR_OS_START_CANONERR))
174 msg += CUnicodeUtils::StdGetUnicode(git_strerror (ErrPtr->apr_err, errbuf, sizeof (errbuf)));
175 /* Otherwise, this must be an APR error code. */
176 else
177 {
178 git_error_t *temp_err = NULL;
179 const char * err_string = NULL;
180 temp_err = git_utf_cstring_to_utf8(&err_string, apr_strerror (ErrPtr->apr_err, errbuf, sizeof (errbuf)-1), ErrPtr->pool);
181 if (temp_err)
182 {
183 git_error_clear (temp_err);
184 msg += _T("Can't recode error string from APR");
185 }
186 else
187 {
188 msg += CUnicodeUtils::StdGetUnicode(err_string);
189 }
190 }
191
192 }
193 }
194 return msg;
195 } // if (m_err != NULL)
196 #endif
197 return msg;
198 }
199 #endif
200
201 // static method
202 git_wc_status_kind GitStatus::GetAllStatus(const CTGitPath& path, git_depth_t depth)
203 {
204 git_wc_status_kind statuskind;
205 // git_client_ctx_t * ctx;
206
207 // apr_pool_t * pool;
208 // git_error_t * err;
209 BOOL err;
210 BOOL isDir;
211 CString sProjectRoot;
212
213 isDir = path.IsDirectory();
214 if (!path.HasAdminDir(&sProjectRoot))
215 return git_wc_status_none;
216
217 // pool = git_pool_create (NULL); // create the memory pool
218
219 // git_error_clear(git_client_create_context(&ctx, pool));
220
221 // git_revnum_t youngest = Git_INVALID_REVNUM;
222 // git_opt_revision_t rev;
223 // rev.kind = git_opt_revision_unspecified;
224 statuskind = git_wc_status_none;
225
226 const BOOL bIsRecursive = (depth == git_depth_infinity || depth == git_depth_unknown); // taken from SVN source
227
228 CString sSubPath;
229 CString s = path.GetWinPathString();
230 if (s.GetLength() > sProjectRoot.GetLength())
231 {
232 if (sProjectRoot.GetLength() == 3 && sProjectRoot[1] == _T(':'))
233 sSubPath = s.Right(s.GetLength() - sProjectRoot.GetLength());
234 else
235 sSubPath = s.Right(s.GetLength() - sProjectRoot.GetLength() - 1/*otherwise it gets initial slash*/);
236 }
237
238 bool isfull;
239
240 #ifdef _TORTOISESHELL
241 isfull = (g_ShellCache.GetCacheType() == ShellCache::dllFull);
242 #else
243 isfull = ((DWORD)CRegStdWORD(_T("Software\\TortoiseGit\\CacheType"),
244 GetSystemMetrics(SM_REMOTESESSION) ? ShellCache::dll : ShellCache::exe) == ShellCache::dllFull);
245 #endif
246
247 if(isDir)
248 {
249 err = GetDirStatus(sProjectRoot,sSubPath,&statuskind, isfull,bIsRecursive,isfull,NULL, NULL);
250
251 }else
252 {
253 err = GetFileStatus(sProjectRoot,sSubPath,&statuskind,isfull, false,isfull, NULL,NULL);
254 }
255
256 return statuskind;
257 }
258
259 // static method
260 git_wc_status_kind GitStatus::GetAllStatusRecursive(const CTGitPath& path)
261 {
262 return GetAllStatus(path, git_depth_infinity);
263 }
264
265 // static method
266 git_wc_status_kind GitStatus::GetMoreImportant(git_wc_status_kind status1, git_wc_status_kind status2)
267 {
268 if (GetStatusRanking(status1) >= GetStatusRanking(status2))
269 return status1;
270 return status2;
271 }
272 // static private method
273 int GitStatus::GetStatusRanking(git_wc_status_kind status)
274 {
275 switch (status)
276 {
277 case git_wc_status_none:
278 return 0;
279 case git_wc_status_unversioned:
280 return 1;
281 case git_wc_status_ignored:
282 return 2;
283 case git_wc_status_incomplete:
284 return 4;
285 case git_wc_status_normal:
286 case git_wc_status_external:
287 return 5;
288 case git_wc_status_added:
289 return 6;
290 case git_wc_status_missing:
291 return 7;
292 case git_wc_status_deleted:
293 return 8;
294 case git_wc_status_replaced:
295 return 9;
296 case git_wc_status_modified:
297 return 10;
298 case git_wc_status_merged:
299 return 11;
300 case git_wc_status_conflicted:
301 return 12;
302 case git_wc_status_obstructed:
303 return 13;
304 }
305 return 0;
306 }
307
308 git_revnum_t GitStatus::GetStatus(const CTGitPath& path, bool update /* = false */, bool noignore /* = false */, bool noexternals /* = false */)
309 {
310 // NOTE: unlike the SVN version this one does not cache the enumerated files, because in practice no code in all of
311 // Tortoise uses this, all places that call GetStatus create a temp GitStatus object which gets destroyed right
312 // after the call again
313
314 // apr_hash_t * statushash;
315 // apr_hash_t * exthash;
316 // apr_array_header_t * statusarray;
317 // const sort_item* item;
318
319 // git_error_clear(m_err);
320 // statushash = apr_hash_make(m_pool);
321 // exthash = apr_hash_make(m_pool);
322 git_revnum_t youngest = GIT_INVALID_REVNUM;
323 // git_opt_revision_t rev;
324 // rev.kind = git_opt_revision_unspecified;
325
326 CString sProjectRoot;
327 if ( !path.HasAdminDir(&sProjectRoot) )
328 return youngest;
329
330 struct hashbaton_t hashbaton;
331 // hashbaton.hash = statushash;
332 // hashbaton.exthash = exthash;
333 hashbaton.pThis = this;
334
335 bool isfull;
336
337 #ifdef _TORTOISESHELL
338 isfull = (g_ShellCache.GetCacheType() == ShellCache::dllFull);
339 #else
340 isfull = ((DWORD)CRegStdWORD(_T("Software\\TortoiseGit\\CacheType"),
341 GetSystemMetrics(SM_REMOTESESSION) ? ShellCache::dll : ShellCache::exe) == ShellCache::dllFull);
342 #endif
343
344 {
345 LPCTSTR lpszSubPath = NULL;
346 CString sSubPath;
347 CString s = path.GetWinPathString();
348 if (s.GetLength() > sProjectRoot.GetLength())
349 {
350 sSubPath = s.Right(s.GetLength() - sProjectRoot.GetLength());
351 lpszSubPath = sSubPath;
352 // skip initial slash if necessary
353 if (*lpszSubPath == _T('\\'))
354 lpszSubPath++;
355 }
356
357 m_status.prop_status = m_status.text_status = git_wc_status_none;
358
359 if(path.IsDirectory())
360 {
361 m_err = GetDirStatus(sProjectRoot,CString(lpszSubPath),&m_status.text_status , isfull, false,!noignore, NULL, NULL);
362
363 }else
364 {
365 m_err = GetFileStatus(sProjectRoot,CString(lpszSubPath),&m_status.text_status ,isfull, false,!noignore, NULL,NULL);
366 }
367 }
368
369 // Error present if function is not under version control
370 if (m_err) /*|| (apr_hash_count(statushash) == 0)*/
371 {
372 status = NULL;
373 return GIT_INVALID_REVNUM;
374 }
375
376 // Convert the unordered hash to an ordered, sorted array
377 /*statusarray = sort_hash (statushash,
378 sort_compare_items_as_paths,
379 m_pool);*/
380
381 // only the first entry is needed (no recurse)
382 // item = &APR_ARRAY_IDX (statusarray, 0, const sort_item);
383
384 // status = (git_wc_status2_t *) item->value;
385 status = &m_status;
386
387 if (update)
388 {
389 // done to match TSVN functionality of this function (not sure if any code uses the reutrn val)
390 // if TGit does not need this, then change the return type of function
391 youngest = g_Git.GetHash(_T("HEAD"));
392 }
393
394 return youngest;
395 }
396
397 git_wc_status2_t * GitStatus::GetFirstFileStatus(const CTGitPath& path, CTGitPath& retPath, bool update, git_depth_t depth, bool bNoIgnore /* = true */, bool bNoExternals /* = false */)
398 {
399 static git_wc_status2 st;
400 /*
401 m_fileCache.Reset();
402
403 m_fileCache.Init( CStringA( path.GetWinPathString().GetString() ) );
404 MessageBox(NULL, path.GetWinPathString(), _T("GetFirstFile"), MB_OK);
405 m_fileCache.m_pFileIter = m_fileCache.m_pFiles;
406 st.text_status = git_wc_status_none;
407
408 if (m_fileCache.m_pFileIter)
409 {
410 switch(m_fileCache.m_pFileIter->nStatus)
411 {
412 case WGFS_Normal: st.text_status = git_wc_status_normal; break;
413 case WGFS_Modified: st.text_status = git_wc_status_modified; break;
414 case WGFS_Deleted: st.text_status = git_wc_status_deleted; break;
415 }
416
417 //retPath.SetFromGit((const char*)item->key);
418
419 m_fileCache.m_pFileIter = m_fileCache.m_pFileIter->pNext;
420 }
421
422 return &st;
423 */
424 #if 0
425 const sort_item* item;
426
427 git_error_clear(m_err);
428 m_statushash = apr_hash_make(m_pool);
429 m_externalhash = apr_hash_make(m_pool);
430 headrev = Git_INVALID_REVNUM;
431 git_opt_revision_t rev;
432 rev.kind = git_opt_revision_unspecified;
433 struct hashbaton_t hashbaton;
434 hashbaton.hash = m_statushash;
435 hashbaton.exthash = m_externalhash;
436 hashbaton.pThis = this;
437 m_statushashindex = 0;
438 m_err = git_client_status4 (&headrev,
439 path.GetGitApiPath(m_pool),
440 &rev,
441 getstatushash,
442 &hashbaton,
443 depth,
444 TRUE, //getall
445 update, //update
446 bNoIgnore, //noignore
447 bNoExternals, //noexternals
448 NULL,
449 ctx,
450 m_pool);
451
452
453 // Error present if function is not under version control
454 if ((m_err != NULL) || (apr_hash_count(m_statushash) == 0))
455 {
456 return NULL;
457 }
458
459 // Convert the unordered hash to an ordered, sorted array
460 m_statusarray = sort_hash (m_statushash,
461 sort_compare_items_as_paths,
462 m_pool);
463
464 // only the first entry is needed (no recurse)
465 m_statushashindex = 0;
466 item = &APR_ARRAY_IDX (m_statusarray, m_statushashindex, const sort_item);
467 retPath.SetFromGit((const char*)item->key);
468 return (git_wc_status2_t *) item->value;
469 #endif
470
471 return 0;
472 }
473
474 unsigned int GitStatus::GetVersionedCount() const
475 {
476 // return /**/m_fileCache.GetFileCount();
477
478 unsigned int count = 0;
479 #if 0
480 const sort_item* item;
481 for (unsigned int i=0; i<apr_hash_count(m_statushash); ++i)
482 {
483 item = &APR_ARRAY_IDX(m_statusarray, i, const sort_item);
484 if (item)
485 {
486 if (GitStatus::GetMoreImportant(((git_wc_status_t *)item->value)->text_status, git_wc_status_ignored)!=git_wc_status_ignored)
487 count++;
488 }
489 }
490 #endif
491 return count;
492 }
493
494 git_wc_status2_t * GitStatus::GetNextFileStatus(CTGitPath& retPath)
495 {
496 static git_wc_status2 st;
497
498 st.text_status = git_wc_status_none;
499
500 /*if (m_fileCache.m_pFileIter)
501 {
502 switch(m_fileCache.m_pFileIter->nStatus)
503 {
504 case WGFS_Normal: st.text_status = git_wc_status_normal; break;
505 case WGFS_Modified: st.text_status = git_wc_status_modified; break;
506 case WGFS_Deleted: st.text_status = git_wc_status_deleted; break;
507 }
508
509 m_fileCache.m_pFileIter = m_fileCache.m_pFileIter->pNext;
510 }*/
511
512 return &st;
513
514 #if 0
515 const sort_item* item;
516
517 if ((m_statushashindex+1) >= apr_hash_count(m_statushash))
518 return NULL;
519 m_statushashindex++;
520
521 item = &APR_ARRAY_IDX (m_statusarray, m_statushashindex, const sort_item);
522 retPath.SetFromGit((const char*)item->key);
523 return (git_wc_status2_t *) item->value;
524 #endif
525 return 0;
526 }
527
528 bool GitStatus::IsExternal(const CTGitPath& path) const
529 {
530 #if 0
531 if (apr_hash_get(m_externalhash, path.GetGitApiPath(m_pool), APR_HASH_KEY_STRING))
532 return true;
533 #endif
534 return false;
535 }
536
537 bool GitStatus::IsInExternal(const CTGitPath& path) const
538 {
539 #if 0
540 if (apr_hash_count(m_statushash) == 0)
541 return false;
542
543 GitPool localpool(m_pool);
544 apr_hash_index_t *hi;
545 const char* key;
546 for (hi = apr_hash_first(localpool, m_externalhash); hi; hi = apr_hash_next(hi))
547 {
548 apr_hash_this(hi, (const void**)&key, NULL, NULL);
549 if (key)
550 {
551 if (CTGitPath(CUnicodeUtils::GetUnicode(key)).IsAncestorOf(path))
552 return true;
553 }
554 }
555 #endif
556 return false;
557 }
558
559
560 void GitStatus::GetStatusString(git_wc_status_kind status, size_t buflen, TCHAR * string)
561 {
562 TCHAR * buf;
563 switch (status)
564 {
565 case git_wc_status_none:
566 buf = _T("none\0");
567 break;
568 case git_wc_status_unversioned:
569 buf = _T("unversioned\0");
570 break;
571 case git_wc_status_normal:
572 buf = _T("normal\0");
573 break;
574 case git_wc_status_added:
575 buf = _T("added\0");
576 break;
577 case git_wc_status_missing:
578 buf = _T("missing\0");
579 break;
580 case git_wc_status_deleted:
581 buf = _T("deleted\0");
582 break;
583 case git_wc_status_replaced:
584 buf = _T("replaced\0");
585 break;
586 case git_wc_status_modified:
587 buf = _T("modified\0");
588 break;
589 case git_wc_status_merged:
590 buf = _T("merged\0");
591 break;
592 case git_wc_status_conflicted:
593 buf = _T("conflicted\0");
594 break;
595 case git_wc_status_obstructed:
596 buf = _T("obstructed\0");
597 break;
598 case git_wc_status_ignored:
599 buf = _T("ignored");
600 break;
601 case git_wc_status_external:
602 buf = _T("external");
603 break;
604 case git_wc_status_incomplete:
605 buf = _T("incomplete\0");
606 break;
607 default:
608 buf = _T("\0");
609 break;
610 }
611 _stprintf_s(string, buflen, _T("%s"), buf);
612 }
613
614 void GitStatus::GetStatusString(HINSTANCE hInst, git_wc_status_kind status, TCHAR * string, int size, WORD lang)
615 {
616 switch (status)
617 {
618 case git_wc_status_none:
619 LoadStringEx(hInst, IDS_STATUSNONE, string, size, lang);
620 break;
621 case git_wc_status_unversioned:
622 LoadStringEx(hInst, IDS_STATUSUNVERSIONED, string, size, lang);
623 break;
624 case git_wc_status_normal:
625 LoadStringEx(hInst, IDS_STATUSNORMAL, string, size, lang);
626 break;
627 case git_wc_status_added:
628 LoadStringEx(hInst, IDS_STATUSADDED, string, size, lang);
629 break;
630 case git_wc_status_missing:
631 LoadStringEx(hInst, IDS_STATUSABSENT, string, size, lang);
632 break;
633 case git_wc_status_deleted:
634 LoadStringEx(hInst, IDS_STATUSDELETED, string, size, lang);
635 break;
636 case git_wc_status_replaced:
637 LoadStringEx(hInst, IDS_STATUSREPLACED, string, size, lang);
638 break;
639 case git_wc_status_modified:
640 LoadStringEx(hInst, IDS_STATUSMODIFIED, string, size, lang);
641 break;
642 case git_wc_status_merged:
643 LoadStringEx(hInst, IDS_STATUSMERGED, string, size, lang);
644 break;
645 case git_wc_status_conflicted:
646 LoadStringEx(hInst, IDS_STATUSCONFLICTED, string, size, lang);
647 break;
648 case git_wc_status_ignored:
649 LoadStringEx(hInst, IDS_STATUSIGNORED, string, size, lang);
650 break;
651 case git_wc_status_obstructed:
652 LoadStringEx(hInst, IDS_STATUSOBSTRUCTED, string, size, lang);
653 break;
654 case git_wc_status_external:
655 LoadStringEx(hInst, IDS_STATUSEXTERNAL, string, size, lang);
656 break;
657 case git_wc_status_incomplete:
658 LoadStringEx(hInst, IDS_STATUSINCOMPLETE, string, size, lang);
659 break;
660 default:
661 LoadStringEx(hInst, IDS_STATUSNONE, string, size, lang);
662 break;
663 }
664 }
665
666 #ifdef _MFC_VER
667 CString GitStatus::GetDepthString(git_depth_t depth)
668 {
669 #if 0
670 CString sDepth;
671 switch (depth)
672 {
673 case git_depth_unknown:
674 sDepth.LoadString(IDS_Git_DEPTH_UNKNOWN);
675 break;
676 case git_depth_empty:
677 sDepth.LoadString(IDS_Git_DEPTH_EMPTY);
678 break;
679 case git_depth_files:
680 sDepth.LoadString(IDS_Git_DEPTH_FILES);
681 break;
682 case git_depth_immediates:
683 sDepth.LoadString(IDS_Git_DEPTH_IMMEDIATE);
684 break;
685 case git_depth_infinity:
686 sDepth.LoadString(IDS_Git_DEPTH_INFINITE);
687 break;
688 }
689 return sDepth;
690 #endif
691 return CString("");
692 }
693 #endif
694
695 void GitStatus::GetDepthString(HINSTANCE hInst, git_depth_t depth, TCHAR * string, int size, WORD lang)
696 {
697 #if 0
698 switch (depth)
699 {
700 case git_depth_unknown:
701 LoadStringEx(hInst, IDS_SVN_DEPTH_UNKNOWN, string, size, lang);
702 break;
703 case git_depth_empty:
704 LoadStringEx(hInst, IDS_SVN_DEPTH_EMPTY, string, size, lang);
705 break;
706 case git_depth_files:
707 LoadStringEx(hInst, IDS_SVN_DEPTH_FILES, string, size, lang);
708 break;
709 case git_depth_immediates:
710 LoadStringEx(hInst, IDS_SVN_DEPTH_IMMEDIATE, string, size, lang);
711 break;
712 case git_depth_infinity:
713 LoadStringEx(hInst, IDS_SVN_DEPTH_INFINITE, string, size, lang);
714 break;
715 }
716 #endif
717 }
718
719
720 int GitStatus::LoadStringEx(HINSTANCE hInstance, UINT uID, LPTSTR lpBuffer, int nBufferMax, WORD wLanguage)
721 {
722 const STRINGRESOURCEIMAGE* pImage;
723 const STRINGRESOURCEIMAGE* pImageEnd;
724 ULONG nResourceSize;
725 HGLOBAL hGlobal;
726 UINT iIndex;
727 int ret;
728
729 HRSRC hResource = FindResourceEx(hInstance, RT_STRING, MAKEINTRESOURCE(((uID>>4)+1)), wLanguage);
730 if (!hResource)
731 {
732 // try the default language before giving up!
733 hResource = FindResource(hInstance, MAKEINTRESOURCE(((uID>>4)+1)), RT_STRING);
734 if (!hResource)
735 return 0;
736 }
737 hGlobal = LoadResource(hInstance, hResource);
738 if (!hGlobal)
739 return 0;
740 pImage = (const STRINGRESOURCEIMAGE*)::LockResource(hGlobal);
741 if(!pImage)
742 return 0;
743
744 nResourceSize = ::SizeofResource(hInstance, hResource);
745 pImageEnd = (const STRINGRESOURCEIMAGE*)(LPBYTE(pImage)+nResourceSize);
746 iIndex = uID&0x000f;
747
748 while ((iIndex > 0) && (pImage < pImageEnd))
749 {
750 pImage = (const STRINGRESOURCEIMAGE*)(LPBYTE(pImage)+(sizeof(STRINGRESOURCEIMAGE)+(pImage->nLength*sizeof(WCHAR))));
751 iIndex--;
752 }
753 if (pImage >= pImageEnd)
754 return 0;
755 if (pImage->nLength == 0)
756 return 0;
757
758 ret = pImage->nLength;
759 if (pImage->nLength > nBufferMax)
760 {
761 wcsncpy_s(lpBuffer, nBufferMax, pImage->achString, pImage->nLength-1);
762 lpBuffer[nBufferMax-1] = 0;
763 }
764 else
765 {
766 wcsncpy_s(lpBuffer, nBufferMax, pImage->achString, pImage->nLength);
767 lpBuffer[ret] = 0;
768 }
769 return ret;
770 }
771
772 BOOL GitStatus::getallstatus(const struct wgFile_s *pFile, void *pUserData)
773 {
774 git_wc_status_kind * s = (git_wc_status_kind *)pUserData;
775 *s = GitStatus::GetMoreImportant(*s, GitStatusFromWingit(pFile->nStatus));
776 return FALSE;
777 }
778
779 BOOL GitStatus::getstatus(const struct wgFile_s *pFile, void *pUserData)
780 {
781 git_wc_status2_t * s = (git_wc_status2_t*)pUserData;
782 s->prop_status = s->text_status = GitStatus::GetMoreImportant(s->prop_status, GitStatusFromWingit(pFile->nStatus));
783 return FALSE;
784 }
785
786 #if 0
787 git_error_t * GitStatus::getallstatus(void * baton, const char * /*path*/, git_wc_status2_t * status, apr_pool_t * /*pool*/)
788 {
789 git_wc_status_kind * s = (git_wc_status_kind *)baton;
790 *s = GitStatus::GetMoreImportant(*s, status->text_status);
791 *s = GitStatus::GetMoreImportant(*s, status->prop_status);
792 return Git_NO_ERROR;
793 }
794 #endif
795
796 #if 0
797 git_error_t * GitStatus::getstatushash(void * baton, const char * path, git_wc_status2_t * status, apr_pool_t * /*pool*/)
798 {
799 hashbaton_t * hash = (hashbaton_t *)baton;
800 const StdStrAVector& filterList = hash->pThis->m_filterFileList;
801 if (status->text_status == git_wc_status_external)
802 {
803 apr_hash_set (hash->exthash, apr_pstrdup(hash->pThis->m_pool, path), APR_HASH_KEY_STRING, (const void*)1);
804 return Git_NO_ERROR;
805 }
806 if(filterList.size() > 0)
807 {
808 // We have a filter active - we're only interested in files which are in
809 // the filter
810 if(!binary_search(filterList.begin(), filterList.end(), path))
811 {
812 // This item is not in the filter - don't store it
813 return Git_NO_ERROR;
814 }
815 }
816 git_wc_status2_t * statuscopy = git_wc_dup_status2 (status, hash->pThis->m_pool);
817 apr_hash_set (hash->hash, apr_pstrdup(hash->pThis->m_pool, path), APR_HASH_KEY_STRING, statuscopy);
818 return Git_NO_ERROR;
819 }
820
821 apr_array_header_t * GitStatus::sort_hash (apr_hash_t *ht,
822 int (*comparison_func) (const GitStatus::sort_item *, const GitStatus::sort_item *),
823 apr_pool_t *pool)
824 {
825 apr_hash_index_t *hi;
826 apr_array_header_t *ary;
827
828 /* allocate an array with only one element to begin with. */
829 ary = apr_array_make (pool, 1, sizeof(sort_item));
830
831 /* loop over hash table and push all keys into the array */
832 for (hi = apr_hash_first (pool, ht); hi; hi = apr_hash_next (hi))
833 {
834 sort_item *item = (sort_item*)apr_array_push (ary);
835
836 apr_hash_this (hi, &item->key, &item->klen, &item->value);
837 }
838
839 /* now quick sort the array. */
840 qsort (ary->elts, ary->nelts, ary->elt_size,
841 (int (*)(const void *, const void *))comparison_func);
842
843 return ary;
844 }
845
846 int GitStatus::sort_compare_items_as_paths (const sort_item *a, const sort_item *b)
847 {
848 const char *astr, *bstr;
849
850 astr = (const char*)a->key;
851 bstr = (const char*)b->key;
852 return git_path_compare_paths (astr, bstr);
853 }
854 #endif
855
856 git_error_t* GitStatus::cancel(void *baton)
857 {
858 #if 0
859 volatile bool * canceled = (bool *)baton;
860 if (*canceled)
861 {
862 CString temp;
863 temp.LoadString(IDS_Git_USERCANCELLED);
864 return git_error_create(Git_ERR_CANCELLED, NULL, CUnicodeUtils::GetUTF8(temp));
865 }
866 return Git_NO_ERROR;
867 #endif
868 return 0;
869 }
870
871 #ifdef _MFC_VER
872
873 // Set-up a filter to restrict the files which will have their status stored by a get-status
874 void GitStatus::SetFilter(const CTGitPathList& fileList)
875 {
876 m_filterFileList.clear();
877 for(int fileIndex = 0; fileIndex < fileList.GetCount(); fileIndex++)
878 {
879 // m_filterFileList.push_back(fileList[fileIndex].GetGitApiPath(m_pool));
880 }
881 // Sort the list so that we can do binary searches
882 std::sort(m_filterFileList.begin(), m_filterFileList.end());
883 }
884
885 void GitStatus::ClearFilter()
886 {
887 m_filterFileList.clear();
888 }
889
890 #endif // _MFC_VER
891
892 typedef CComCritSecLock<CComCriticalSection> CAutoLocker;
893
894 int GitStatus::GetFileStatus(CString &gitdir,CString &path,git_wc_status_kind * status,BOOL IsFull, BOOL IsRecursive,BOOL IsIgnore, FIll_STATUS_CALLBACK callback,void *pData)
895 {
896 try
897 {
898
899 TCHAR oldpath[MAX_PATH+1];
900 memset(oldpath,0,MAX_PATH+1);
901
902 path.Replace(_T('\\'),_T('/'));
903
904 if(status)
905 {
906 git_wc_status_kind st = git_wc_status_none;
907 CGitHash hash;
908
909 g_IndexFileMap.GetFileStatus(gitdir,path,&st,IsFull,false,callback,pData,&hash);
910
911 if( st == git_wc_status_conflicted )
912 {
913 *status =st;
914 if(callback)
915 callback(gitdir+_T("/")+path,st,false,pData);
916 return 0;
917 }
918
919 if( st == git_wc_status_unversioned )
920 {
921 if(!IsIgnore)
922 {
923 *status = git_wc_status_unversioned;
924 if(callback)
925 callback(gitdir+_T("/")+path, *status, false,pData);
926 return 0;
927 }
928
929 if( g_IgnoreList.CheckIgnoreChanged(gitdir,path))
930 {
931 g_IgnoreList.LoadAllIgnoreFile(gitdir,path);
932 }
933 if( g_IgnoreList.IsIgnore(path, gitdir) )
934 {
935 st = git_wc_status_ignored;
936 }
937 *status = st;
938 if(callback)
939 callback(gitdir+_T("/")+path,st, false, pData);
940
941 return 0;
942 }
943
944 if( st == git_wc_status_normal && IsFull)
945 {
946 {
947 int ret=g_HeadFileMap.CheckHeadUpdate(gitdir);
948 bool b=false;
949
950 CAutoReadLock lock(&g_HeadFileMap.m_SharedMutex);
951
952 {
953 CAutoReadLock lock(&g_HeadFileMap[gitdir].m_SharedMutex);
954 b = g_HeadFileMap[gitdir].m_Head != g_HeadFileMap[gitdir].m_TreeHash;
955 }
956
957 if(ret || b)
958 {
959 g_HeadFileMap[gitdir].ReadHeadHash(gitdir);
960 // Init Repository
961 if( g_HeadFileMap[gitdir].m_HeadFile.IsEmpty() )
962 {
963 *status =st=git_wc_status_added;
964 if(callback)
965 callback(gitdir+_T("/")+path,st,false,pData);
966 return 0;
967 }
968 if(g_HeadFileMap[gitdir].ReadTree())
969 {
970 g_HeadFileMap[gitdir].m_LastModifyTimeHead = 0;
971 //Check if init repository
972 *status = g_HeadFileMap[gitdir].m_Head.IsEmpty()? git_wc_status_added: st;
973 if(callback)
974 callback(gitdir+_T("/")+path,*status,false,pData);
975 return 0;
976 }
977
978 }
979 // Check Head Tree Hash;
980 {
981 CAutoReadLock lock(&g_HeadFileMap[gitdir].m_SharedMutex);
982
983 //add item
984 std::map<CString,int>::iterator it=g_HeadFileMap[gitdir].m_Map.find(path);
985
986 if(it == g_HeadFileMap[gitdir].m_Map.end())
987 {
988 *status =st=git_wc_status_added;
989 ATLTRACE(_T("File miss in head tree %s"), path);
990 if(callback)
991 callback(gitdir+_T("/")+path,st,false, pData);
992 return 0;
993 }
994
995 //staged and not commit
996 if( g_HeadFileMap[gitdir].at(it->second).m_Hash != hash )
997 {
998 *status =st=git_wc_status_modified;
999 if(callback)
1000 callback(gitdir+_T("/")+path,st, false, pData);
1001 return 0;
1002 }
1003 }
1004 }
1005 }
1006 *status =st;
1007 if(callback)
1008 callback(gitdir+_T("/")+path,st,false, pData);
1009 return 0;
1010 }
1011 }
1012 catch(...)
1013 {
1014 if(status)
1015 *status = git_wc_status_none;
1016 return -1;
1017 }
1018
1019 return 0;
1020
1021 }
1022
1023 int GitStatus::GetHeadHash(CString &gitdir, CGitHash &hash)
1024 {
1025 return g_HeadFileMap.GetHeadHash(gitdir, hash);
1026 }
1027
1028 bool GitStatus::IsGitReposChanged(CString &gitdir,CString &subpaths, int mode)
1029 {
1030 if( mode & GIT_MODE_INDEX)
1031 {
1032 bool load = true;
1033 g_IndexFileMap.CheckAndUpdateIndex(gitdir,&load);
1034 return load;
1035 }
1036
1037 if( mode & GIT_MODE_HEAD)
1038 {
1039 if(g_HeadFileMap.CheckHeadUpdate(gitdir))
1040 return true;
1041 }
1042
1043 if( mode & GIT_MODE_IGNORE)
1044 {
1045 if(g_IgnoreList.CheckIgnoreChanged(gitdir,subpaths))
1046 return true;
1047 }
1048 return false;
1049 }
1050
1051 int GitStatus::LoadIgnoreFile(CString &gitdir,CString &subpaths)
1052 {
1053 return g_IgnoreList.LoadAllIgnoreFile(gitdir,subpaths);
1054 }
1055 int GitStatus::IsUnderVersionControl(CString &gitdir, CString &path, bool isDir,bool *isVersion)
1056 {
1057 return g_IndexFileMap.IsUnderVersionControl(gitdir, path, isDir, isVersion);
1058 }
1059
1060 __int64 GitStatus::GetIndexFileTime(CString &gitdir)
1061 {
1062 CAutoReadLock lock(&g_IndexFileMap.m_SharedMutex);
1063
1064 if(g_IndexFileMap.find(gitdir) == g_IndexFileMap.end())
1065 return 0;
1066
1067 return g_IndexFileMap[gitdir].m_LastModifyTime;
1068 }
1069
1070 int GitStatus::GetIgnoreFileChangeTimeList(CString &dir, std::vector<__int64> &timelist)
1071 {
1072 return g_IgnoreList.GetIgnoreFileChangeTimeList(dir,timelist);
1073 }
1074 int GitStatus::IsIgnore(CString &gitdir, CString &path, bool *isIgnore)
1075 {
1076 if(::g_IgnoreList.CheckIgnoreChanged(gitdir,path))
1077 g_IgnoreList.LoadAllIgnoreFile(gitdir,path);
1078
1079 *isIgnore = g_IgnoreList.IsIgnore(path,gitdir);
1080
1081 return 0;
1082 }
1083
1084 int GitStatus::EnumDirStatus(CString &gitdir,CString &subpath,git_wc_status_kind * status,BOOL IsFul, BOOL IsRecursive, BOOL IsIgnore, FIll_STATUS_CALLBACK callback, void *pData)
1085 {
1086 try
1087 {
1088 TCHAR oldpath[MAX_PATH+1];
1089 memset(oldpath,0,MAX_PATH+1);
1090
1091 CString path =subpath;
1092
1093 path.Replace(_T('\\'),_T('/'));
1094 if(!path.IsEmpty())
1095 if(path[path.GetLength()-1] != _T('/'))
1096 path += _T('/'); //Add trail / to show it is directory, not file name.
1097
1098 if(status)
1099 {
1100 g_IndexFileMap.CheckAndUpdateIndex(gitdir);
1101
1102 int pos;
1103
1104 {
1105 CAutoReadLock lock(&g_IndexFileMap.m_SharedMutex);
1106 CAutoReadLock lock1(&g_IndexFileMap[gitdir].m_SharedMutex);
1107
1108 pos=SearchInSortVector(g_IndexFileMap[gitdir],path.GetBuffer(),path.GetLength());
1109 }
1110
1111 if(subpath.IsEmpty() && pos<0)
1112 { // for new init repository
1113 *status = git_wc_status_normal;
1114 if(callback)
1115 callback(gitdir+_T("/")+path, *status, false,pData);
1116 return 0;
1117 }
1118
1119 //Not In Version Contorl
1120 if(pos<0)
1121 {
1122 if(!IsIgnore)
1123 {
1124 *status = git_wc_status_unversioned;
1125 if(callback)
1126 callback(gitdir+_T("/")+path, *status, false,pData);
1127 return 0;
1128 }
1129 //Check ignore always.
1130 {
1131 if(::g_IgnoreList.CheckIgnoreChanged(gitdir,path))
1132 g_IgnoreList.LoadAllIgnoreFile(gitdir,path);
1133
1134 if(g_IgnoreList.IsIgnore(path,gitdir))
1135 *status = git_wc_status_ignored;
1136 else
1137 *status = git_wc_status_unversioned;
1138
1139 g_HeadFileMap.CheckHeadUpdate(gitdir);
1140
1141 //Check init repository
1142
1143 {
1144 CAutoReadLock lock(&g_HeadFileMap.m_SharedMutex);
1145 CAutoReadLock lock1(&g_HeadFileMap[gitdir].m_SharedMutex);
1146
1147 if(g_HeadFileMap[gitdir].m_Head.IsEmpty() && path.IsEmpty())
1148 *status = git_wc_status_normal;
1149 }
1150 }
1151
1152 }else // In version control
1153 {
1154 *status = git_wc_status_normal;
1155
1156 g_IndexFileMap.m_SharedMutex.AcquireShared();
1157 g_IndexFileMap[gitdir].m_SharedMutex.AcquireShared();
1158
1159 int start=0;
1160 int end=0;
1161 if(path.IsEmpty())
1162 {
1163 start=0;
1164 end=g_IndexFileMap[gitdir].size()-1;
1165 }
1166
1167 GetRangeInSortVector(g_IndexFileMap[gitdir],path.GetBuffer(),path.GetLength(),&start,&end,pos);
1168 CGitIndexList::iterator it;
1169
1170 it = g_IndexFileMap[gitdir].begin()+start;
1171
1172 CString sub, currentPath;
1173
1174 for(int i=start;i<=end;i++,it++)
1175 {
1176 if( ((*it).m_Flags & CE_STAGEMASK) !=0)
1177 {
1178 *status = git_wc_status_conflicted;
1179 }
1180
1181 if( !IsRecursive )
1182 {
1183 //skip child directory
1184 int pos = (*it).m_FileName.Find(_T('/'), path.GetLength());
1185
1186 if( pos > 0)
1187 {
1188 currentPath = (*it).m_FileName.Left(pos);
1189 if( callback && (sub != currentPath) )
1190 {
1191 sub = currentPath;
1192 ATLTRACE(_T("index subdir %s\n"),sub);
1193 if(callback)
1194 {
1195 g_IndexFileMap[gitdir].m_SharedMutex.ReleaseShared();
1196 g_IndexFileMap.m_SharedMutex.ReleaseShared();
1197 callback(gitdir + _T("\\")+sub, git_wc_status_normal,true, pData);
1198 g_IndexFileMap.m_SharedMutex.AcquireShared();
1199 g_IndexFileMap[gitdir].m_SharedMutex.AcquireShared();
1200 }
1201 }
1202 continue;
1203 }
1204 }
1205
1206 git_wc_status_kind filestatus = git_wc_status_none;
1207
1208 g_IndexFileMap[gitdir].m_SharedMutex.ReleaseShared();
1209 g_IndexFileMap.m_SharedMutex.ReleaseShared();
1210 GetFileStatus(gitdir,(*it).m_FileName, &filestatus,IsFul, IsRecursive,IsIgnore, callback,pData);
1211 g_IndexFileMap.m_SharedMutex.AcquireShared();
1212 g_IndexFileMap[gitdir].m_SharedMutex.AcquireShared();
1213
1214 *status = max(filestatus, *status) ;
1215 }
1216
1217 //Check Miss file in index "git rm file"
1218 if( IsFul && (*status != git_wc_status_conflicted))
1219 {
1220 if(g_HeadFileMap.CheckHeadUpdate(gitdir) || g_HeadFileMap.IsHashChanged(gitdir))
1221 {
1222 CAutoReadLock lock(&g_HeadFileMap.m_SharedMutex);
1223
1224 g_HeadFileMap[gitdir].ReadHeadHash(gitdir);
1225
1226 if(g_HeadFileMap[gitdir].ReadTree())
1227 {
1228 //try again
1229 g_Git.SetCurrentDir(gitdir);
1230 ::GetCurrentDirectory(MAX_PATH,oldpath);
1231 ::SetCurrentDirectory(g_Git.m_CurrentDir);
1232 git_init();
1233 g_HeadFileMap[gitdir].ReadTree();
1234 }
1235 }
1236 //Check Add
1237 it = ::g_IndexFileMap[gitdir].begin()+start;
1238
1239 {
1240 CAutoReadLock lock(&g_HeadFileMap.m_SharedMutex);
1241 CAutoReadLock lock1(&g_HeadFileMap[gitdir].m_SharedMutex);
1242
1243 //Check if new init repository
1244 if( g_HeadFileMap[gitdir].size() > 0 || g_HeadFileMap[gitdir].m_Head.IsEmpty() )
1245 {
1246 //Check Delete
1247 if( *status == git_wc_status_normal )
1248 {
1249 pos = SearchInSortVector(g_HeadFileMap[gitdir], path.GetBuffer(), path.GetLength());
1250 if(pos <0)
1251 {
1252 *status = max(git_wc_status_added, *status) ;
1253
1254 }else
1255 {
1256 int hstart,hend;
1257 GetRangeInSortVector(g_HeadFileMap[gitdir],path.GetBuffer(),path.GetLength(),&hstart,&hend,pos);
1258 CGitHeadFileList::iterator hit;
1259 hit = g_HeadFileMap[gitdir].begin()+hstart;
1260 for(int i=hstart;i<=hend;i++)
1261 {
1262 if( ::g_IndexFileMap[gitdir].m_Map.find((*hit).m_FileName) == g_IndexFileMap[gitdir].m_Map.end())
1263 {
1264 *status =max(git_wc_status_deleted, *status);
1265 break;
1266 }
1267 hit++;
1268 }
1269 }
1270 } // endif if( *status == git_wc_status_normal )
1271 }// endif if( g_HeadFileMap[gitdir].size() > 0 || g_HeadFileMap[gitdir].m_Head.IsEmpty() )
1272 }
1273 }
1274
1275 g_IndexFileMap[gitdir].m_SharedMutex.ReleaseShared();
1276 g_IndexFileMap.m_SharedMutex.ReleaseShared();
1277
1278 }// end inversion control
1279 if(callback) callback(gitdir+_T("/")+subpath,*status,true, pData);
1280 }//endi if status
1281
1282 if(*oldpath!=0)
1283 ::SetCurrentDirectory(oldpath);
1284 }catch(...)
1285 {
1286 if(status)
1287 *status = git_wc_status_none;
1288 }
1289
1290 return 0;
1291
1292 }
1293 int GitStatus::GetDirStatus(CString &gitdir,CString &subpath,git_wc_status_kind * status,BOOL IsFul, BOOL IsRecursive,BOOL IsIgnore,FIll_STATUS_CALLBACK callback,void *pData)
1294 {
1295 try
1296 {
1297 TCHAR oldpath[MAX_PATH+1];
1298 memset(oldpath,0,MAX_PATH+1);
1299
1300 CString path =subpath;
1301
1302 path.Replace(_T('\\'),_T('/'));
1303 if(!path.IsEmpty())
1304 if(path[path.GetLength()-1] != _T('/'))
1305 path += _T('/'); //Add trail / to show it is directory, not file name.
1306
1307 if(status)
1308 {
1309 g_IndexFileMap.CheckAndUpdateIndex(gitdir);
1310
1311 CAutoReadLock lock(&g_IndexFileMap.m_SharedMutex);
1312 CAutoReadLock lock1(&g_IndexFileMap[gitdir].m_SharedMutex);
1313
1314 int pos=SearchInSortVector(g_IndexFileMap[gitdir],path.GetBuffer(),path.GetLength());
1315
1316 if(subpath.IsEmpty() && pos<0)
1317 { // for new init repository
1318 *status = git_wc_status_normal;
1319 if(callback)
1320 callback(gitdir+_T("/")+path, *status, false,pData);
1321 return 0;
1322 }
1323
1324 //Not In Version Contorl
1325 if(pos<0)
1326 {
1327 if(!IsIgnore)
1328 {
1329 *status = git_wc_status_unversioned;
1330 if(callback)
1331 callback(gitdir+_T("/")+path, *status, false,pData);
1332 return 0;
1333 }
1334 //Check ignore always.
1335 {
1336 if(::g_IgnoreList.CheckIgnoreChanged(gitdir,path))
1337 g_IgnoreList.LoadAllIgnoreFile(gitdir,path);
1338
1339 if(g_IgnoreList.IsIgnore(path,gitdir))
1340 *status = git_wc_status_ignored;
1341 else
1342 *status = git_wc_status_unversioned;
1343
1344 g_HeadFileMap.CheckHeadUpdate(gitdir);
1345
1346 CAutoReadLock lock(&g_HeadFileMap.m_SharedMutex);
1347 CAutoReadLock lock1(&g_HeadFileMap[gitdir].m_SharedMutex);
1348 //Check init repository
1349 if(g_HeadFileMap[gitdir].m_Head.IsEmpty() && path.IsEmpty())
1350 *status = git_wc_status_normal;
1351 }
1352
1353 }else // In version control
1354 {
1355 *status = git_wc_status_normal;
1356
1357 int start=0;
1358 int end=0;
1359 if(path.IsEmpty())
1360 {
1361 start=0;
1362 end=g_IndexFileMap[gitdir].size()-1;
1363 }
1364 GetRangeInSortVector(g_IndexFileMap[gitdir],path.GetBuffer(),path.GetLength(),&start,&end,pos);
1365 CGitIndexList::iterator it;
1366
1367 it = g_IndexFileMap[gitdir].begin()+start;
1368
1369 // Check Conflict;
1370 for(int i=start;i<=end;i++)
1371 {
1372 if( ((*it).m_Flags & CE_STAGEMASK) !=0)
1373 {
1374 *status = git_wc_status_conflicted;
1375 if(callback)
1376 {
1377 int dirpos = (*it).m_FileName.Find(_T('/'), path.GetLength());
1378 if(dirpos<0 || IsRecursive)
1379 callback(gitdir+_T("\\")+ it->m_FileName,git_wc_status_conflicted,false,pData);
1380 }else
1381 break;
1382 }
1383 it++;
1384 }
1385
1386 if( IsFul && (*status != git_wc_status_conflicted))
1387 {
1388 *status = git_wc_status_normal;
1389
1390 if(g_HeadFileMap.CheckHeadUpdate(gitdir))
1391 {
1392 CAutoReadLock lock(&g_HeadFileMap.m_SharedMutex);
1393 CAutoReadLock lock1(&g_HeadFileMap[gitdir].m_SharedMutex);
1394
1395 g_HeadFileMap[gitdir].ReadHeadHash(gitdir);
1396
1397 if(g_HeadFileMap[gitdir].ReadTree())
1398 {
1399 //try again
1400 g_Git.SetCurrentDir(gitdir);
1401 ::GetCurrentDirectory(MAX_PATH,oldpath);
1402 ::SetCurrentDirectory(g_Git.m_CurrentDir);
1403 git_init();
1404 g_HeadFileMap[gitdir].ReadTree();
1405 }
1406 }
1407 //Check Add
1408 it = ::g_IndexFileMap[gitdir].begin()+start;
1409
1410
1411 {
1412 CAutoReadLock lock(&g_HeadFileMap.m_SharedMutex);
1413 CAutoReadLock lock1(&g_HeadFileMap[gitdir].m_SharedMutex);
1414
1415
1416 //Check if new init repository
1417 if( g_HeadFileMap[gitdir].size() > 0 || g_HeadFileMap[gitdir].m_Head.IsEmpty() )
1418 {
1419 for(int i=start;i<=end;i++)
1420 {
1421 if( g_HeadFileMap[gitdir].m_Map.find((*it).m_FileName) == g_HeadFileMap[gitdir].m_Map.end())
1422 {
1423 pos = -1;
1424 }else
1425 pos = g_HeadFileMap[gitdir].m_Map[(*it).m_FileName];
1426
1427 if(pos < 0)
1428 {
1429 *status = *status = max(git_wc_status_added, *status) ;
1430 if(callback)
1431 {
1432 int dirpos = (*it).m_FileName.Find(_T('/'), path.GetLength());
1433 if(dirpos<0 || IsRecursive)
1434 callback(gitdir+_T("\\")+ it->m_FileName,git_wc_status_added,false, pData);
1435
1436 }else
1437 break;
1438 }
1439
1440 if( pos>=0 && g_HeadFileMap[gitdir][pos].m_Hash != (*it).m_IndexHash)
1441 {
1442 *status = *status = max(git_wc_status_modified, *status) ;
1443 if(callback)
1444 {
1445 int dirpos = (*it).m_FileName.Find(_T('/'), path.GetLength());
1446 if(dirpos<0 || IsRecursive)
1447 callback(gitdir+_T("\\")+ it->m_FileName, git_wc_status_modified,false, pData);
1448
1449 }else
1450 break;
1451 }
1452
1453 it++;
1454 }
1455
1456 //Check Delete
1457 if( *status == git_wc_status_normal )
1458 {
1459 pos = SearchInSortVector(g_HeadFileMap[gitdir], path.GetBuffer(), path.GetLength());
1460 if(pos <0)
1461 {
1462 *status = git_wc_status_added;
1463
1464 }else
1465 {
1466 int hstart,hend;
1467 GetRangeInSortVector(g_HeadFileMap[gitdir],path.GetBuffer(),path.GetLength(),&hstart,&hend,pos);
1468 CGitHeadFileList::iterator hit;
1469 hit = g_HeadFileMap[gitdir].begin()+start;
1470 for(int i=hstart;i<=hend;i++)
1471 {
1472 if( ::g_IndexFileMap[gitdir].m_Map.find((*hit).m_FileName) == g_IndexFileMap[gitdir].m_Map.end())
1473 {
1474 *status = git_wc_status_deleted;
1475 break;
1476 }
1477 hit++;
1478 }
1479 }
1480 }
1481 }
1482 }/* End lock*/
1483 }
1484 // If define callback, it need update each file status.
1485 // If not define callback, status == git_wc_status_conflicted, needn't check each file status
1486 // because git_wc_status_conflicted is highest.s
1487 if(callback || (*status != git_wc_status_conflicted))
1488 {
1489 //Check File Time;
1490 //if(IsRecursive)
1491 {
1492 CString sub, currentPath;
1493 it = g_IndexFileMap[gitdir].begin()+start;
1494 for(int i=start;i<=end;i++,it++)
1495 {
1496 if( !IsRecursive )
1497 {
1498 //skip child directory
1499 int pos = (*it).m_FileName.Find(_T('/'), path.GetLength());
1500
1501 if( pos > 0)
1502 {
1503 currentPath = (*it).m_FileName.Left(pos);
1504 if( callback && (sub != currentPath) )
1505 {
1506 sub = currentPath;
1507 ATLTRACE(_T("index subdir %s\n"),sub);
1508 if(callback) callback(gitdir + _T("\\")+sub,
1509 git_wc_status_normal,true, pData);
1510 }
1511 continue;
1512 }
1513 }
1514
1515 git_wc_status_kind filestatus = git_wc_status_none;
1516
1517 GetFileStatus(gitdir,(*it).m_FileName, &filestatus,IsFul, IsRecursive,IsIgnore, callback,pData);
1518
1519 *status = max(filestatus, *status) ;
1520 }
1521 }
1522 }
1523 }
1524
1525 if(callback) callback(gitdir+_T("/")+subpath,*status,true, pData);
1526 }
1527
1528 if(*oldpath!=0)
1529 ::SetCurrentDirectory(oldpath);
1530
1531 }catch(...)
1532 {
1533 if(status)
1534 *status = git_wc_status_none;
1535 return -1;
1536 }
1537
1538 return 0;
1539 }
1540
1541 bool GitStatus::IsExistIndexLockFile(CString &gitdir)
1542 {
1543 CString sDirName= gitdir;
1544
1545 for (;;)
1546 {
1547 if(PathFileExists(sDirName + _T("\\.git")))
1548 {
1549 if(PathFileExists(sDirName + _T("\\.git\\index.lock")))
1550 return true;
1551 else
1552 return false;
1553 }
1554
1555 int x = sDirName.ReverseFind(_T('\\'));
1556 if (x < 2)
1557 return false;
1558
1559 sDirName = sDirName.Left(x);
1560 }
1561
1562 return false;
1563 }
Windows Explorer Extension to Operate Git