src/Git/GitIndex.cpp

   1 #include "StdAfx.h"
   2 #include "Git.h"
   3 #include "atlconv.h"
   4 #include "GitRev.h"
   5 #include "registry.h"
   6 #include "GitConfig.h"
   7 #include <map>
   8 #include "UnicodeUtils.h"
   9 #include "TGitPath.h"
  10 #include "gitindex.h"
  11 #include <sys/types.h>
  12 #include <sys/stat.h>
  13
  14 typedef CComCritSecLock<CComCriticalSection> CAutoLocker;
  15
  16 #define FILL_DATA() \
  17         m_FileName.Empty();\
  18         g_Git.StringAppend(&m_FileName,(BYTE*)entry->name,CP_ACP,Big2lit(entry->flags)&CE_NAMEMASK);\
  19         this->m_Flags=Big2lit(entry->flags);\
  20         this->m_ModifyTime=Big2lit(entry->mtime.sec);\
  21         this->m_IndexHash=(char*)(entry->sha1);
  22
  23 int CGitIndex::FillData(ondisk_cache_entry * entry)
  24 {
  25         FILL_DATA();
  26         return 0;
  27 }
  28
  29 int CGitIndex::FillData(ondisk_cache_entry_extended * entry)
  30 {
  31         FILL_DATA();
  32         this->m_Flags |= ((int)Big2lit(entry->flags2))<<16;
  33         return 0;
  34 }
  35
  36 int CGitIndex::Print()
  37 {
  38         _tprintf(_T("0x%08X  0x%08X %s %s\n"),
  39                 (int)this->m_ModifyTime,
  40                 this->m_Flags,
  41                 this->m_IndexHash.ToString(),
  42                 this->m_FileName);
  43
  44         return 0;
  45 }
  46
  47 CGitIndexList::CGitIndexList()
  48 {
  49         this->m_LastModifyTime=0;
  50 }
  51
  52 int CGitIndexList::ReadIndex(CString IndexFile)
  53 {
  54         HANDLE hfile=0;
  55         int ret=0;
  56         BYTE *buffer=NULL,*p;
  57         CGitIndex GitIndex;
  58
  59         try
  60         {
  61                 do
  62                 {
  63                         this->clear();
  64                         this->m_Map.clear();
  65
  66                         hfile = CreateFile(IndexFile,
  67                                                                         GENERIC_READ,
  68                                                                         FILE_SHARE_READ,
  69                                                                         NULL,
  70                                                                         OPEN_EXISTING,
  71                                                                         FILE_ATTRIBUTE_NORMAL,
  72                                                                         NULL);
  73
  74
  75                         if(hfile == INVALID_HANDLE_VALUE)
  76                         {
  77                                 ret = -1 ;
  78                                 break;
  79                         }
  80
  81                         cache_header *header;
  82                         DWORD size=0,filesize=0;
  83
  84                         filesize=GetFileSize(hfile,NULL);
  85
  86                         if(filesize == INVALID_FILE_SIZE )
  87                         {
  88                                 ret =-1;
  89                                 break;
  90                         }
  91
  92                         buffer = new BYTE[filesize];
  93                         p=buffer;
  94                         if(buffer == NULL)
  95                         {
  96                                 ret = -1;
  97                                 break;
  98                         }
  99                         if(! ReadFile( hfile, buffer,filesize,&size,NULL) )
 100                         {
 101                                 ret = GetLastError();
 102                                 break;
 103                         }
 104
 105                         if (size != filesize)
 106                         {
 107                                 ret = -1;
 108                                 break;
 109                         }
 110                         header = (cache_header *) buffer;
 111                         if( Big2lit(header->hdr_signature) != CACHE_SIGNATURE )
 112                         {
 113                                 ret = -1;
 114                                 break;
 115                         }
 116                         p+= sizeof(cache_header);
 117
 118                         int entries = Big2lit(header->hdr_entries);
 119                         for(int i=0;i<entries;i++)
 120                         {
 121                                 ondisk_cache_entry *entry;
 122                                 ondisk_cache_entry_extended *entryex;
 123                                 entry=(ondisk_cache_entry*)p;
 124                                 entryex=(ondisk_cache_entry_extended*)p;
 125                                 int flags=Big2lit(entry->flags);
 126                                 if( flags & CE_EXTENDED)
 127                                 {
 128                                         GitIndex.FillData(entryex);
 129                                         p+=ondisk_ce_size(entryex);
 130
 131                                 }else
 132                                 {
 133                                         GitIndex.FillData(entry);
 134                                         p+=ondisk_ce_size(entry);
 135                                 }
 136
 137                                 if(p>buffer+filesize)
 138                                 {
 139                                         ret = -1;
 140                                         break;
 141                                 }
 142                                 this->push_back(GitIndex);
 143                                 this->m_Map[GitIndex.m_FileName]=this->size()-1;
 144
 145                         }
 146                 }while(0);
 147         }catch(...)
 148         {
 149                 ret= -1;
 150         }
 151
 152         if(hfile != INVALID_HANDLE_VALUE)
 153                 CloseHandle(hfile);
 154         if(buffer)
 155                 delete buffer;
 156         return ret;
 157 }
 158
 159 int CGitIndexList::GetFileStatus(CString &gitdir,CString &path,git_wc_status_kind *status,__int64 time,FIll_STATUS_CALLBACK callback,void *pData, CGitHash *pHash)
 160 {
 161
 162         if(status)
 163         {
 164                 if(m_Map.find(path) == m_Map.end() )
 165                 {
 166                         *status = git_wc_status_unversioned;
 167
 168                         if(pHash)
 169                                 pHash->Empty();
 170
 171                 }else
 172                 {
 173                         int index = m_Map[path];
 174                         if(index <0)
 175                                 return -1;
 176                         if(index >= size() )
 177                                 return -1;
 178
 179                         if( time ==  at(index).m_ModifyTime )
 180                         {
 181                                 *status = git_wc_status_normal;
 182                         }else
 183                         {
 184                                 *status = git_wc_status_modified;
 185                         }
 186
 187                         if(at(index).m_Flags & CE_STAGEMASK )
 188                                 *status = git_wc_status_conflicted;
 189                         else if(at(index).m_Flags & CE_INTENT_TO_ADD)
 190                                 *status = git_wc_status_added;
 191
 192                         if(pHash)
 193                                 *pHash = at(index).m_IndexHash;
 194                 }
 195                 if(callback)
 196                         callback(gitdir+_T("\\")+path,*status,false, pData);
 197         }
 198         return 0;
 199 }
 200
 201 int CGitIndexList::GetStatus(CString &gitdir,CString &path, git_wc_status_kind *status,
 202                                                          BOOL IsFull, BOOL IsRecursive,
 203                                                          FIll_STATUS_CALLBACK callback,void *pData,
 204                                                          CGitHash *pHash)
 205 {
 206         int result;
 207         git_wc_status_kind dirstatus = git_wc_status_none;
 208         __int64 time;
 209         bool isDir=false;
 210
 211         if(status)
 212         {
 213                 if(path.IsEmpty())
 214                         result = g_Git.GetFileModifyTime(gitdir,&time,&isDir);
 215                 else
 216                         result = g_Git.GetFileModifyTime( gitdir+_T("\\")+path, &time, &isDir );
 217
 218                 if(result)
 219                 {
 220                         *status = git_wc_status_deleted;
 221                         if(callback)
 222                                 callback(gitdir+_T("\\")+path,git_wc_status_deleted,false, pData);
 223
 224                         return 0;
 225                 }
 226                 if(isDir)
 227                 {
 228                         if(!path.IsEmpty())
 229                         {
 230                                 if( path.Right(1) != _T("\\"))
 231                                         path+=_T("\\");
 232                         }
 233                         int len =path.GetLength();
 234
 235                         for(int i=0;i<size();i++)
 236                         {
 237                                 if( at(i).m_FileName.GetLength() > len )
 238                                 {
 239                                         if(at(i).m_FileName.Left(len) == path)
 240                                         {
 241                                                 if( !IsFull )
 242                                                 {
 243                                                         *status = git_wc_status_normal;
 244                                                         if(callback)
 245                                                                 callback(gitdir+_T("\\")+path,*status,false, pData);
 246                                                         return 0;
 247
 248                                                 }else
 249                                                 {
 250                                                         result = g_Git.GetFileModifyTime( gitdir+_T("\\")+at(i).m_FileName , &time);
 251                                                         if(result)
 252                                                                 continue;
 253
 254                                                         *status = git_wc_status_none;
 255                                                         GetFileStatus(gitdir,at(i).m_FileName,status,time,callback,pData);
 256                                                         if( *status != git_wc_status_none )
 257                                                         {
 258                                                                 if( dirstatus == git_wc_status_none)
 259                                                                 {
 260                                                                         dirstatus = git_wc_status_normal;
 261                                                                 }
 262                                                                 if( *status != git_wc_status_normal )
 263                                                                 {
 264                                                                         dirstatus = git_wc_status_modified;
 265                                                                 }
 266                                                         }
 267
 268                                                 }
 269                                         }
 270                                 }
 271                         }
 272
 273                         if( dirstatus != git_wc_status_none )
 274                         {
 275                                 *status = dirstatus;
 276                         }
 277                         else
 278                         {
 279                                 *status = git_wc_status_unversioned;
 280                         }
 281                         if(callback)
 282                                 callback(gitdir+_T("\\")+path,*status,false, pData);
 283
 284                         return 0;
 285
 286                 }else
 287                 {
 288                         GetFileStatus(gitdir,path,status,time,callback,pData,pHash);
 289                 }
 290         }
 291         return 0;
 292 }
 293
 294 int CGitIndexFileMap::CheckAndUpdateIndex(CString &gitdir,bool *loaded)
 295 {
 296         __int64 time;
 297         int result;
 298
 299         try
 300         {
 301                 CString IndexFile;
 302                 IndexFile=gitdir+_T("\\.git\\index");
 303                 /* Get data associated with "crt_stat.c": */
 304                 result = g_Git.GetFileModifyTime( IndexFile, &time );
 305
 306 //              WIN32_FILE_ATTRIBUTE_DATA FileInfo;
 307 //              GetFileAttributesEx(_T("D:\\tortoisegit\\src\\gpl.txt"),GetFileExInfoStandard,&FileInfo);
 308 //              result = _tstat64( _T("D:\\tortoisegit\\src\\gpl.txt"), &buf );
 309
 310                 if(loaded)
 311                         *loaded = false;
 312
 313                 if(result)
 314                    return result;
 315
 316                 if((*this)[gitdir].m_LastModifyTime != time )
 317                 {
 318                         if((*this)[gitdir].ReadIndex(IndexFile))
 319                                 return -1;
 320                         if(loaded)
 321                                 *loaded =true;
 322                 }
 323                 (*this)[gitdir].m_LastModifyTime = time;
 324
 325         }catch(...)
 326         {
 327                 return -1;
 328         }
 329         return 0;
 330 }
 331
 332 int CGitIndexFileMap::GetFileStatus(CString &gitdir, CString &path, git_wc_status_kind *status,BOOL IsFull, BOOL IsRecursive,
 333                                                                         FIll_STATUS_CALLBACK callback,void *pData,
 334                                                                         CGitHash *pHash)
 335 {
 336         int result;
 337         try
 338         {
 339                 CheckAndUpdateIndex(gitdir);
 340                 (*this)[gitdir].GetStatus(gitdir,path,status,IsFull,IsRecursive,callback,pData,pHash);
 341
 342         }catch(...)
 343         {
 344                 return -1;
 345         }
 346         return 0;
 347 }
 348
 349 int CGitIndexFileMap::IsUnderVersionControl(CString &gitdir, CString &path, bool isDir,bool *isVersion)
 350 {
 351         try
 352         {
 353                 if(path.IsEmpty())
 354                 {
 355                         *isVersion =true;
 356                         return 0;
 357                 }
 358                 CString subpath=path;
 359                 subpath.Replace(_T('\\'), _T('/'));
 360                 if(isDir)
 361                         subpath+=_T('/');
 362
 363                 CheckAndUpdateIndex(gitdir);
 364                 if(isDir)
 365                 {
 366                         *isVersion = (SearchInSortVector((*this)[gitdir], subpath.GetBuffer(), subpath.GetLength()) >= 0);
 367                 }
 368                 else
 369                 {
 370                         *isVersion = ((*this)[gitdir].m_Map.find(subpath) != (*this)[gitdir].m_Map.end());
 371                 }
 372
 373         }catch(...)
 374         {
 375                 return -1;
 376         }
 377         return 0;
 378 }
 379 int CGitHeadFileList::ReadHeadHash(CString gitdir)
 380 {
 381         CString HeadFile = gitdir;
 382         HeadFile += _T("\\.git\\HEAD");
 383         HANDLE hfile;
 384
 385         m_Gitdir = gitdir;
 386
 387         m_HeadFile = HeadFile;
 388
 389         if( g_Git.GetFileModifyTime(m_HeadFile,&m_LastModifyTimeHead))
 390                 return -1;
 391
 392         hfile = CreateFile(HeadFile,
 393                                                 GENERIC_READ,
 394                                                 FILE_SHARE_READ,
 395                                                 NULL,
 396                                                 OPEN_EXISTING,
 397                                                 FILE_ATTRIBUTE_NORMAL,
 398                                                 NULL);
 399
 400         if(hfile == INVALID_HANDLE_VALUE)
 401                 return -1;
 402
 403         DWORD size=0,filesize=0;
 404         unsigned char buffer[40] ;
 405         ReadFile(hfile,buffer,4,&size,NULL);
 406         if(size !=4)
 407                 return -1;
 408
 409         buffer[4]=0;
 410         if(strcmp((const char*)buffer,"ref:") == 0)
 411         {
 412                 filesize = GetFileSize(hfile,NULL);
 413
 414                 unsigned char *p = (unsigned char*)malloc(filesize -4);
 415
 416                 ReadFile(hfile,p,filesize-4,&size,NULL);
 417
 418                 m_HeadRefFile.Empty();
 419                 g_Git.StringAppend(&this->m_HeadRefFile,p,CP_ACP,filesize-4);
 420                 free(p);
 421                 m_HeadRefFile=gitdir+_T("\\.git\\")+m_HeadRefFile.Trim();
 422                 m_HeadRefFile.Replace(_T('/'),_T('\\'));
 423
 424                 __int64 time;
 425                 if(g_Git.GetFileModifyTime(m_HeadRefFile,&time,NULL))
 426                         return -1;
 427
 428
 429                 HANDLE href;
 430                 href = CreateFile(m_HeadRefFile,
 431                                                 GENERIC_READ,
 432                                                 FILE_SHARE_READ,
 433                                                 NULL,
 434                                                 OPEN_EXISTING,
 435                                                 FILE_ATTRIBUTE_NORMAL,
 436                                                 NULL);
 437
 438                 if(href == INVALID_HANDLE_VALUE)
 439                         return -1;
 440
 441                 ReadFile(href,buffer,40,&size,NULL);
 442                 if(size != 40)
 443                         return -1;
 444
 445                 this->m_Head.ConvertFromStrA((char*)buffer);
 446                 CloseHandle(href);
 447                 this->m_LastModifyTimeRef = time;
 448
 449         }else
 450         {
 451                 ReadFile(hfile,buffer+4,40-4,&size,NULL);
 452                 if(size !=36)
 453                         return -1;
 454
 455                 m_HeadRefFile.Empty();
 456
 457                 this->m_Head.ConvertFromStrA((char*)buffer);
 458         }
 459
 460         CloseHandle(hfile);
 461 }
 462
 463 bool CGitHeadFileList::CheckHeadUpdate()
 464 {
 465         if(this->m_HeadFile.IsEmpty())
 466                 return true;
 467
 468         __int64 mtime=0;
 469
 470         if( g_Git.GetFileModifyTime(m_HeadFile,&mtime))
 471                 return true;
 472
 473         if(mtime != this->m_LastModifyTimeHead)
 474                 return true;
 475
 476         if(!this->m_HeadRefFile.IsEmpty())
 477         {
 478                 if(g_Git.GetFileModifyTime(m_HeadRefFile,&mtime))
 479                         return true;
 480
 481                 if(mtime != this->m_LastModifyTimeRef)
 482                         return true;
 483         }
 484
 485         return false;
 486 }
 487
 488 int CGitHeadFileList::ReadTree()
 489 {
 490         if( this->m_Head.IsEmpty())
 491                 return -1;
 492
 493         CAutoLocker lock(g_Git.m_critGitDllSec);
 494
 495         if(m_Gitdir != g_Git.m_CurrentDir)
 496         {
 497                 g_Git.SetCurrentDir(m_Gitdir);
 498                 SetCurrentDirectory(g_Git.m_CurrentDir);
 499                 git_init();
 500         }
 501         return git_read_tree(this->m_Head.m_hash,CGitHeadFileList::CallBack,this);
 502 }
 503
 504 int CGitHeadFileList::CallBack(const unsigned char *sha1, const char *base, int baselen,
 505                 const char *pathname, unsigned mode, int stage, void *context)
 506 {
 507 #define S_IFGITLINK     0160000
 508
 509         CGitHeadFileList *p = (CGitHeadFileList*)context;
 510         if( mode&S_IFDIR )
 511         {
 512                 if( (mode&S_IFMT) != S_IFGITLINK)
 513                         return READ_TREE_RECURSIVE;
 514         }
 515
 516         unsigned int cur = p->size();
 517         p->resize(p->size()+1);
 518         p->at(cur).m_Hash = (char*)sha1;
 519         p->at(cur).m_FileName.Empty();
 520
 521         if(base)
 522                 g_Git.StringAppend(&p->at(cur).m_FileName,(BYTE*)base,CP_ACP,baselen);
 523
 524         g_Git.StringAppend(&p->at(cur).m_FileName,(BYTE*)pathname,CP_ACP);
 525
 526         //p->at(cur).m_FileName.Replace(_T('/'),_T('\\'));
 527
 528         p->m_Map[p->at(cur).m_FileName]=cur;
 529
 530         if( (mode&S_IFMT) == S_IFGITLINK)
 531                 return 0;
 532
 533         return READ_TREE_RECURSIVE;
 534 }
 535
 536 int CGitIgnoreItem::FetchIgnoreList(CString &file)
 537 {
 538         if(this->m_pExcludeList)
 539         {
 540                 free(m_pExcludeList);
 541                 m_pExcludeList=NULL;
 542         }
 543         {
 544
 545                 if(g_Git.GetFileModifyTime(file,&m_LastModifyTime))
 546                         return -1;
 547
 548                 if(git_create_exclude_list(&this->m_pExcludeList))
 549                         return -1;
 550
 551
 552                 HANDLE hfile = CreateFile(file,
 553                         GENERIC_READ,
 554                         FILE_SHARE_READ,
 555                         NULL,
 556                         OPEN_EXISTING,
 557                         FILE_ATTRIBUTE_NORMAL,
 558                         NULL);
 559
 560
 561                 if(hfile == INVALID_HANDLE_VALUE)
 562                 {
 563                         return -1 ;
 564                 }
 565
 566                 DWORD size=0,filesize=0;
 567
 568                 filesize=GetFileSize(hfile,NULL);
 569
 570                 if(filesize == INVALID_FILE_SIZE )
 571                 {
 572                         return -1;
 573                 }
 574
 575                 BYTE *buffer = new BYTE[filesize+1];
 576
 577                 if(buffer == NULL)
 578                 {
 579                         return -1;
 580                 }
 581
 582                 if(! ReadFile( hfile, buffer,filesize,&size,NULL) )
 583                 {
 584                         return GetLastError();
 585                 }
 586
 587                 BYTE *p = buffer;
 588                 for(int i=0;i<size;i++)
 589                 {
 590                         if( buffer[i] == '\n' || buffer[i] =='\r' || i==(size-1) )
 591                         {
 592                                 if( i== size-1)
 593                                         buffer[size]=0;
 594                                 else
 595                                         buffer[i]=0;
 596
 597                                 if(p[0] != '#' && p[0] != 0)
 598                                         git_add_exclude((const char*)p, 0,0,this->m_pExcludeList);
 599
 600                                 p=buffer+i+1;
 601                         }
 602                 }
 603                 //delete buffer;
 604                 //buffer=NULL;
 605         }
 606 }
 607
 608 bool CGitIgnoreList::CheckFileChanged(CString &path)
 609 {
 610         __int64 time=0;
 611         int ret=g_Git.GetFileModifyTime(path, &time);
 612
 613         bool cacheExist = (m_Map.find(path) != m_Map.end());
 614         // both cache and file is not exist
 615         if( (ret != 0) && (!cacheExist))
 616                 return false;
 617
 618         // file exist but cache miss
 619         if( (ret == 0) && (!cacheExist))
 620                 return true;
 621
 622         // file not exist but cache exist
 623         if( (ret != 0) && (cacheExist))
 624                 return true;
 625
 626         // file exist and cache exist
 627         if( m_Map[path].m_LastModifyTime == time )
 628                 return false;
 629
 630         return true;
 631
 632 }
 633
 634 bool CGitIgnoreList::CheckIgnoreChanged(CString &gitdir,CString &path)
 635 {
 636         CString temp;
 637         temp=gitdir;
 638         temp+=_T("\\");
 639         temp+=path;
 640
 641         while(!temp.IsEmpty())
 642         {
 643                 temp+=_T("\\.git");
 644
 645                 if(PathFileExists(temp))
 646                 {
 647                         CString gitignore=temp;
 648                         gitignore += _T("ignore");
 649                         if( CheckFileChanged(gitignore) )
 650                                 return true;
 651
 652                         temp+=_T("\\info\\exclude");
 653
 654                         if( CheckFileChanged(temp) )
 655                                 return true;
 656                         else
 657                                 return false;
 658                 }else
 659                 {
 660                         temp+=_T("ignore");
 661                         if( CheckFileChanged(temp) )
 662                                 return true;
 663                 }
 664
 665                 int found=0;
 666                 int i;
 667                 for( i=temp.GetLength() -1;i>=0;i--)
 668                 {
 669                         if(temp[i] == _T('\\'))
 670                                 found ++;
 671
 672                         if(found == 2)
 673                                 break;
 674                 }
 675
 676                 temp = temp.Left(i);
 677         }
 678         return true;
 679 }
 680
 681 int CGitIgnoreList::LoadAllIgnoreFile(CString &gitdir,CString &path)
 682 {
 683         CString temp;
 684
 685         temp=gitdir;
 686         temp+=_T("\\");
 687         temp+=path;
 688
 689         while(!temp.IsEmpty())
 690         {
 691                 temp+=_T("\\.git");
 692
 693                 if(PathFileExists(temp))
 694                 {
 695                         CString gitignore = temp;
 696                         gitignore += _T("ignore");
 697                         if( CheckFileChanged(gitignore) )
 698                         {
 699                                 m_Map[gitignore].FetchIgnoreList(gitignore);
 700                         }
 701
 702                         temp+=_T("\\info\\exclude");
 703
 704                         if( CheckFileChanged(temp) )
 705                         {
 706                                 return m_Map[temp].FetchIgnoreList(temp);
 707                         }
 708
 709                 }else
 710                 {
 711                         temp+=_T("ignore");
 712                         if( CheckFileChanged(temp) )
 713                         {
 714                                 m_Map[temp].FetchIgnoreList(temp);
 715                         }
 716                 }
 717
 718                 int found=0;
 719                 int i;
 720                 for( i=temp.GetLength() -1;i>=0;i--)
 721                 {
 722                         if(temp[i] == _T('\\'))
 723                                 found ++;
 724
 725                         if(found == 2)
 726                                 break;
 727                 }
 728
 729                 temp = temp.Left(i);
 730         }
 731         return true;
 732 }
 733 bool CGitIgnoreList::IsIgnore(CString &path,CString &projectroot)
 734 {
 735         CString str=path;
 736
 737         str.Replace(_T('\\'),_T('/'));
 738
 739         int ret;
 740         ret = CheckIgnore(path, projectroot);
 741         while(ret < 0)
 742         {
 743                 int start=str.ReverseFind(_T('/'));
 744                 if(start<0)
 745                         return (ret == 1);
 746
 747                 str=str.Left(start);
 748                 ret = CheckIgnore(str, projectroot);
 749         }
 750
 751         return (ret == 1);
 752 }
 753 int CGitIgnoreList::CheckIgnore(CString &path,CString &projectroot)
 754 {
 755         __int64 time=0;
 756         bool dir=0;
 757         CString temp=projectroot+_T("\\")+path;
 758         CStringA patha;
 759
 760         patha = CUnicodeUtils::GetMulti(path,CP_ACP) ;
 761         patha.Replace('\\','/');
 762
 763         if(g_Git.GetFileModifyTime(temp,&time,&dir))
 764                 return -1;
 765
 766         int type=0;
 767         if( dir )
 768                 type = DT_DIR;
 769         else
 770                 type = DT_REG;
 771
 772         while(!temp.IsEmpty())
 773         {
 774                 int x;
 775                 x=temp.ReverseFind(_T('\\'));
 776                 if(x<0) x=0;
 777                         temp=temp.Left(x);
 778
 779                 temp+=_T("\\.gitignore");
 780                 if(this->m_Map.find(temp) == m_Map.end() )
 781                 {
 782
 783                 }else
 784                 {
 785                         char *base;
 786
 787                         patha.Replace('\\', '/');
 788                         int pos=patha.ReverseFind('/');
 789                         base = pos>=0? patha.GetBuffer()+pos+1:patha.GetBuffer();
 790
 791                         int ret=git_check_excluded_1( patha, patha.GetLength(), base, &type, m_Map[temp].m_pExcludeList);
 792                         if(ret == 1)
 793                                 return 1;
 794                         if(ret == 0)
 795                                 return 0;
 796                 }
 797
 798                 temp = temp.Left(temp.GetLength()-11);
 799                 temp +=_T("\\.git\\info\\exclude");
 800
 801                 if(this->m_Map.find(temp) == m_Map.end() )
 802                 {
 803
 804                 }else
 805                 {
 806                         int ret=git_check_excluded_1( patha, patha.GetLength(), NULL,&type, m_Map[temp].m_pExcludeList);
 807                         if(ret == 1)
 808                                 return 1;
 809                         if(ret == 0)
 810                                 return 0;
 811
 812                         return -1;
 813                 }
 814                 temp = temp.Left(temp.GetLength()-18);
 815         }
 816
 817         return -1;
 818 }
 819
 820 #if 0
 821
 822 int CGitStatus::GetStatus(CString &gitdir, CString &path, git_wc_status_kind *status, BOOL IsFull, BOOL IsRecursive , FIll_STATUS_CALLBACK callback , void *pData)
 823 {
 824         int result;
 825         __int64 time;
 826         bool    dir;
 827
 828         git_wc_status_kind dirstatus = git_wc_status_none;
 829         if(status)
 830         {
 831                 g_Git.GetFileModifyTime(path,&time,&dir);
 832                 if( dir)
 833                 {
 834                 }else
 835                 {
 836
 837                 }
 838                 if(path.IsEmpty())
 839                         result = _tstat64( gitdir, &buf );
 840                 else
 841                         result = _tstat64( gitdir+_T("\\")+path, &buf );
 842
 843                 if(result)
 844                         return -1;
 845
 846                 if(buf.st_mode & _S_IFDIR)
 847                 {
 848                         if(!path.IsEmpty())
 849                         {
 850                                 if( path.Right(1) != _T("\\"))
 851                                         path+=_T("\\");
 852                         }
 853                         int len =path.GetLength();
 854
 855                         for(int i=0;i<size();i++)
 856                         {
 857                                 if( at(i).m_FileName.GetLength() > len )
 858                                 {
 859                                         if(at(i).m_FileName.Left(len) == path)
 860                                         {
 861                                                 if( !IsFull )
 862                                                 {
 863                                                         *status = git_wc_status_normal;
 864                                                         if(callback)
 865                                                                 callback(gitdir+_T("\\")+path,*status,pData);
 866                                                         return 0;
 867
 868                                                 }else
 869                                                 {
 870                                                         result = _tstat64( gitdir+_T("\\")+at(i).m_FileName, &buf );
 871                                                         if(result)
 872                                                                 continue;
 873
 874                                                         *status = git_wc_status_none;
 875                                                         GetFileStatus(gitdir,at(i).m_FileName,status,buf,callback,pData);
 876                                                         if( *status != git_wc_status_none )
 877                                                         {
 878                                                                 if( dirstatus == git_wc_status_none)
 879                                                                 {
 880                                                                         dirstatus = git_wc_status_normal;
 881                                                                 }
 882                                                                 if( *status != git_wc_status_normal )
 883                                                                 {
 884                                                                         dirstatus = git_wc_status_modified;
 885                                                                 }
 886                                                         }
 887
 888                                                 }
 889                                         }
 890                                 }
 891                         }
 892
 893                         if( dirstatus != git_wc_status_none )
 894                         {
 895                                 *status = dirstatus;
 896                         }
 897                         else
 898                         {
 899                                 *status = git_wc_status_unversioned;
 900                         }
 901                         if(callback)
 902                                 callback(gitdir+_T("\\")+path,*status,pData);
 903
 904                         return 0;
 905
 906                 }else
 907                 {
 908                         GetFileStatus(gitdir,path,status,buf,callback,pData);
 909                 }
 910         }
 911         return 0;
 912
 913 }
 914 #endif