src/Git/Git.cpp

   1 #include "StdAfx.h"\r
   2 #include "Git.h"\r
   3 #include "atlconv.h"\r
   4 #include "GitRev.h"\r
   5 #include "registry.h"\r
   6 #include "GitConfig.h"\r
   7 #include <map>\r
   8 #include "UnicodeUtils.h"\r
   9 \r
  10 int CGit::m_LogEncode=CP_UTF8;\r
  11 \r
  12 \r
  13 static LPTSTR nextpath(LPCTSTR src, LPTSTR dst, UINT maxlen)\r
  14 {\r
  15         LPCTSTR orgsrc;\r
  16 \r
  17         while (*src == _T(';'))\r
  18                 src++;\r
  19 \r
  20         orgsrc = src;\r
  21 \r
  22         if (!--maxlen)\r
  23                 goto nullterm;\r
  24 \r
  25         while (*src && *src != _T(';'))\r
  26         {\r
  27                 if (*src != _T('"'))\r
  28                 {\r
  29                         *dst++ = *src++;\r
  30                         if (!--maxlen)\r
  31                         {\r
  32                                 orgsrc = src;\r
  33                                 goto nullterm;\r
  34                         }\r
  35                 }\r
  36                 else\r
  37                 {\r
  38                         src++;\r
  39                         while (*src && *src != _T('"'))\r
  40                         {\r
  41                                 *dst++ = *src++;\r
  42                                 if (!--maxlen)\r
  43                                 {\r
  44                                         orgsrc = src;\r
  45                                         goto nullterm;\r
  46                                 }\r
  47                         }\r
  48 \r
  49                         if (*src)\r
  50                                 src++;\r
  51                 }\r
  52         }\r
  53 \r
  54         while (*src == _T(';'))\r
  55                 src++;\r
  56 \r
  57 nullterm:\r
  58 \r
  59         *dst = 0;\r
  60 \r
  61         return (orgsrc != src) ? (LPTSTR)src : NULL;\r
  62 }\r
  63 \r
  64 static inline BOOL FileExists(LPCTSTR lpszFileName)\r
  65 {\r
  66         struct _stat st;\r
  67         return _tstat(lpszFileName, &st) == 0;\r
  68 }\r
  69 \r
  70 static BOOL FindGitPath()\r
  71 {\r
  72         size_t size;\r
  73         _tgetenv_s(&size, NULL, 0, _T("PATH"));\r
  74 \r
  75         if (!size)\r
  76         {\r
  77                 return FALSE;\r
  78         }\r
  79 \r
  80         TCHAR *env = (TCHAR*)alloca(size * sizeof(TCHAR));\r
  81         _tgetenv_s(&size, env, size, _T("PATH"));\r
  82 \r
  83         TCHAR buf[_MAX_PATH];\r
  84 \r
  85         // search in all paths defined in PATH\r
  86         while ((env = nextpath(env, buf, _MAX_PATH-1)) && *buf)\r
  87         {\r
  88                 TCHAR *pfin = buf + _tcslen(buf)-1;\r
  89 \r
  90                 // ensure trailing slash\r
  91                 if (*pfin != _T('/') && *pfin != _T('\\'))\r
  92                         _tcscpy(++pfin, _T("\\"));\r
  93 \r
  94                 const int len = _tcslen(buf);\r
  95 \r
  96                 if ((len + 7) < _MAX_PATH)\r
  97                         _tcscpy(pfin+1, _T("git.exe"));\r
  98                 else\r
  99                         break;\r
 100 \r
 101                 if ( FileExists(buf) )\r
 102                 {\r
 103                         // dir found\r
 104                         pfin[1] = 0;\r
 105                         CGit::ms_LastMsysGitDir = buf;\r
 106                         return TRUE;\r
 107                 }\r
 108         }\r
 109 \r
 110         return FALSE;\r
 111 }\r
 112 \r
 113 \r
 114 #define MAX_DIRBUFFER 1000\r
 115 #define CALL_OUTPUT_READ_CHUNK_SIZE 1024\r
 116 \r
 117 CString CGit::ms_LastMsysGitDir;\r
 118 CGit g_Git;\r
 119 \r
 120 // contains system environment that should be used by child processes (RunAsync)\r
 121 // initialized by CheckMsysGitDir\r
 122 static LPTSTR l_processEnv = NULL;\r
 123 \r
 124 \r
 125 \r
 126 CGit::CGit(void)\r
 127 {\r
 128         GetCurrentDirectory(MAX_DIRBUFFER,m_CurrentDir.GetBuffer(MAX_DIRBUFFER));\r
 129         m_CurrentDir.ReleaseBuffer();\r
 130         m_IsGitDllInited = false;\r
 131         CheckMsysGitDir();\r
 132 }\r
 133 \r
 134 CGit::~CGit(void)\r
 135 {\r
 136 }\r
 137 \r
 138 static char g_Buffer[4096];\r
 139 \r
 140 int CGit::RunAsync(CString cmd,PROCESS_INFORMATION *piOut,HANDLE *hReadOut,CString *StdioFile)\r
 141 {\r
 142         SECURITY_ATTRIBUTES sa;\r
 143         HANDLE hRead, hWrite;\r
 144         HANDLE hStdioFile = NULL;\r
 145 \r
 146         sa.nLength = sizeof(SECURITY_ATTRIBUTES);\r
 147         sa.lpSecurityDescriptor=NULL;\r
 148         sa.bInheritHandle=TRUE;\r
 149         if(!CreatePipe(&hRead,&hWrite,&sa,0))\r
 150         {\r
 151                 return GIT_ERROR_OPEN_PIP;\r
 152         }\r
 153         \r
 154         if(StdioFile)\r
 155         {\r
 156                 hStdioFile=CreateFile(*StdioFile,GENERIC_WRITE,FILE_SHARE_READ   |   FILE_SHARE_WRITE,   \r
 157                         &sa,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);  \r
 158         }\r
 159 \r
 160         STARTUPINFO si;\r
 161         PROCESS_INFORMATION pi;\r
 162         si.cb=sizeof(STARTUPINFO);\r
 163         GetStartupInfo(&si);\r
 164 \r
 165         si.hStdError=hWrite;\r
 166         if(StdioFile)\r
 167                 si.hStdOutput=hStdioFile;\r
 168         else\r
 169                 si.hStdOutput=hWrite;\r
 170 \r
 171         si.wShowWindow=SW_HIDE;\r
 172         si.dwFlags=STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;\r
 173 \r
 174         LPTSTR pEnv = l_processEnv;\r
 175         DWORD dwFlags = pEnv ? CREATE_UNICODE_ENVIRONMENT : 0;\r
 176         \r
 177         //DETACHED_PROCESS make ssh recognize that it has no console to launch askpass to input password. \r
 178         dwFlags |= DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP; \r
 179 \r
 180         memset(&this->m_CurrentGitPi,0,sizeof(PROCESS_INFORMATION));\r
 181 \r
 182         if(!CreateProcess(NULL,(LPWSTR)cmd.GetString(), NULL,NULL,TRUE,dwFlags,pEnv,(LPWSTR)m_CurrentDir.GetString(),&si,&pi))\r
 183         {\r
 184                 LPVOID lpMsgBuf;\r
 185                 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,\r
 186                         NULL,GetLastError(),MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),\r
 187                         (LPTSTR)&lpMsgBuf,\r
 188                         0,NULL);\r
 189                 return GIT_ERROR_CREATE_PROCESS;\r
 190         }\r
 191         \r
 192         m_CurrentGitPi = pi;\r
 193         \r
 194         CloseHandle(hWrite);\r
 195         if(piOut)\r
 196                 *piOut=pi;\r
 197         if(hReadOut)\r
 198                 *hReadOut=hRead;\r
 199         \r
 200         return 0;\r
 201 \r
 202 }\r
 203 //Must use sperate function to convert ANSI str to union code string\r
 204 //Becuase A2W use stack as internal convert buffer. \r
 205 void CGit::StringAppend(CString *str,BYTE *p,int code,int length)\r
 206 {\r
 207      //USES_CONVERSION;\r
 208          //str->Append(A2W_CP((LPCSTR)p,code));\r
 209         if(str == NULL)\r
 210                 return ;\r
 211 \r
 212         WCHAR * buf;\r
 213 \r
 214         int len ;\r
 215         if(length<0)\r
 216                 len= strlen((const char*)p);\r
 217         else\r
 218                 len=length;\r
 219         //if (len==0)\r
 220         //      return ;\r
 221         //buf = new WCHAR[len*4 + 1];\r
 222         buf = str->GetBuffer(len*4+1+str->GetLength())+str->GetLength();\r
 223         SecureZeroMemory(buf, (len*4 + 1)*sizeof(WCHAR));\r
 224         MultiByteToWideChar(code, 0, (LPCSTR)p, len, buf, len*4);\r
 225         str->ReleaseBuffer();\r
 226         //str->Append(buf);\r
 227         //delete buf;\r
 228 }       \r
 229 BOOL CGit::IsInitRepos()\r
 230 {\r
 231         CString cmdout;\r
 232         cmdout.Empty();\r
 233         if(g_Git.Run(_T("git.exe rev-parse --revs-only HEAD"),&cmdout,CP_UTF8))\r
 234         {\r
 235         //      CMessageBox::Show(NULL,cmdout,_T("TortoiseGit"),MB_OK);\r
 236                 return TRUE;\r
 237         }\r
 238         if(cmdout.IsEmpty())\r
 239                 return TRUE;\r
 240 \r
 241         return FALSE;\r
 242 }\r
 243 int CGit::Run(CGitCall* pcall)\r
 244 {\r
 245         PROCESS_INFORMATION pi;\r
 246         HANDLE hRead;\r
 247         if(RunAsync(pcall->GetCmd(),&pi,&hRead))\r
 248                 return GIT_ERROR_CREATE_PROCESS;\r
 249 \r
 250         DWORD readnumber;\r
 251         BYTE data[CALL_OUTPUT_READ_CHUNK_SIZE];\r
 252         bool bAborted=false;\r
 253         while(ReadFile(hRead,data,CALL_OUTPUT_READ_CHUNK_SIZE,&readnumber,NULL))\r
 254         {\r
 255                 //Todo: when OnOutputData() returns 'true', abort git-command. Send CTRL-C signal?\r
 256                 if(!bAborted)//For now, flush output when command aborted.\r
 257                         if(pcall->OnOutputData(data,readnumber))\r
 258                                 bAborted=true;\r
 259         }\r
 260         if(!bAborted)\r
 261                 pcall->OnEnd();\r
 262 \r
 263         \r
 264         CloseHandle(pi.hThread);\r
 265 \r
 266         WaitForSingleObject(pi.hProcess, INFINITE);\r
 267         DWORD exitcode =0;\r
 268 \r
 269         if(!GetExitCodeProcess(pi.hProcess,&exitcode))\r
 270         {\r
 271                 return GIT_ERROR_GET_EXIT_CODE;\r
 272         }\r
 273 \r
 274         CloseHandle(pi.hProcess);\r
 275 \r
 276         CloseHandle(hRead);\r
 277         return exitcode;\r
 278 }\r
 279 class CGitCall_ByteVector : public CGitCall\r
 280 {\r
 281 public:\r
 282         CGitCall_ByteVector(CString cmd,BYTE_VECTOR* pvector):CGitCall(cmd),m_pvector(pvector){}\r
 283         virtual bool OnOutputData(const BYTE* data, size_t size)\r
 284         {\r
 285                 size_t oldsize=m_pvector->size();\r
 286                 m_pvector->resize(m_pvector->size()+size);\r
 287                 memcpy(&*(m_pvector->begin()+oldsize),data,size);\r
 288                 return false;\r
 289         }\r
 290         BYTE_VECTOR* m_pvector;\r
 291 \r
 292 };\r
 293 int CGit::Run(CString cmd,BYTE_VECTOR *vector)\r
 294 {\r
 295         CGitCall_ByteVector call(cmd,vector);\r
 296         return Run(&call);\r
 297 }\r
 298 int CGit::Run(CString cmd, CString* output,int code)\r
 299 {\r
 300         BYTE_VECTOR vector;\r
 301         int ret;\r
 302         ret=Run(cmd,&vector);\r
 303 \r
 304         vector.push_back(0);\r
 305         \r
 306         StringAppend(output,&(vector[0]),code);\r
 307         return ret;\r
 308 }\r
 309 \r
 310 CString CGit::GetUserName(void)\r
 311 {\r
 312         return GetConfigValue(L"user.name");\r
 313 }\r
 314 CString CGit::GetUserEmail(void)\r
 315 {\r
 316         return GetConfigValue(L"user.email");\r
 317 }\r
 318 \r
 319 CString CGit::GetConfigValue(CString name)\r
 320 {\r
 321         CString configValue;\r
 322         CString cmd;\r
 323         cmd.Format(L"git.exe config %s", name);\r
 324         Run(cmd,&configValue,CP_UTF8);\r
 325         int start = 0;\r
 326         return configValue.Tokenize(_T("\n"),start);\r
 327 }\r
 328 \r
 329 \r
 330 CString CGit::GetCurrentBranch(void)\r
 331 {\r
 332         CString output;\r
 333         //Run(_T("git.exe branch"),&branch);\r
 334 \r
 335         int ret=g_Git.Run(_T("git.exe branch --no-color"),&output,CP_UTF8);\r
 336         if(!ret)\r
 337         {               \r
 338                 int pos=0;\r
 339                 CString one;\r
 340                 while( pos>=0 )\r
 341                 {\r
 342                         //i++;\r
 343                         one=output.Tokenize(_T("\n"),pos);\r
 344                         //list.push_back(one.Right(one.GetLength()-2));\r
 345                         if(one[0] == _T('*'))\r
 346                                 return one.Right(one.GetLength()-2);\r
 347                 }\r
 348         }\r
 349         return CString("");\r
 350 }\r
 351 \r
 352 CString CGit::GetSymbolicRef(const wchar_t* symbolicRefName, bool bStripRefsHeads)\r
 353 {\r
 354         CString refName;\r
 355         CString cmd;\r
 356         cmd.Format(L"git symbolic-ref %s", symbolicRefName);\r
 357         if(Run(cmd, &refName, CP_UTF8) != 0)\r
 358                 return CString();//Error\r
 359         int iStart = 0;\r
 360         refName = refName.Tokenize(L"\n", iStart);\r
 361         if(bStripRefsHeads)\r
 362                 refName = StripRefName(refName);\r
 363         return refName;\r
 364 }\r
 365 \r
 366 CString CGit::GetFullRefName(CString shortRefName)\r
 367 {\r
 368         CString refName;\r
 369         CString cmd;\r
 370         cmd.Format(L"git rev-parse --symbolic-full-name %s", shortRefName);\r
 371         if(Run(cmd, &refName, CP_UTF8) != 0)\r
 372                 return CString();//Error\r
 373         int iStart = 0;\r
 374         return refName.Tokenize(L"\n", iStart);\r
 375 }\r
 376 \r
 377 CString CGit::StripRefName(CString refName)\r
 378 {\r
 379         if(wcsncmp(refName, L"refs/heads/", 11) == 0)\r
 380                 refName = refName.Mid(11);\r
 381         else if(wcsncmp(refName, L"refs/", 5) == 0)\r
 382                 refName = refName.Mid(5);\r
 383         return refName;\r
 384 }\r
 385 \r
 386 int CGit::GetCurrentBranchFromFile(const CString &sProjectRoot, CString &sBranchOut)\r
 387 {\r
 388         // read current branch name like git-gui does, by parsing the .git/HEAD file directly\r
 389 \r
 390         if ( sProjectRoot.IsEmpty() )\r
 391                 return -1;\r
 392 \r
 393         CString sHeadFile = sProjectRoot + _T("\\") + g_GitAdminDir.GetAdminDirName() + _T("\\HEAD");\r
 394 \r
 395         FILE *pFile;\r
 396         _tfopen_s(&pFile, sHeadFile.GetString(), _T("r"));\r
 397 \r
 398         if (!pFile)\r
 399         {\r
 400                 return -1;\r
 401         }\r
 402 \r
 403         char s[256] = {0};\r
 404     fgets(s, sizeof(s), pFile);\r
 405 \r
 406         fclose(pFile);\r
 407 \r
 408         const char *pfx = "ref: refs/heads/";\r
 409         const int len = 16;//strlen(pfx)\r
 410 \r
 411         if ( !strncmp(s, pfx, len) )\r
 412         {\r
 413                 //# We're on a branch.  It might not exist.  But\r
 414                 //# HEAD looks good enough to be a branch.\r
 415                 sBranchOut = s + len;\r
 416                 sBranchOut.TrimRight(_T(" \r\n\t"));\r
 417 \r
 418                 if ( sBranchOut.IsEmpty() )\r
 419                         return -1;\r
 420         }\r
 421         else\r
 422         {\r
 423                 //# Assume this is a detached head.\r
 424                 sBranchOut = "HEAD";\r
 425 \r
 426                 return 1;\r
 427         }\r
 428 \r
 429         return 0;\r
 430 }\r
 431 \r
 432 int CGit::BuildOutputFormat(CString &format,bool IsFull)\r
 433 {\r
 434         CString log;\r
 435         log.Format(_T("#<%c>%%x00"),LOG_REV_ITEM_BEGIN);\r
 436         format += log;\r
 437         if(IsFull)\r
 438         {\r
 439                 log.Format(_T("#<%c>%%an%%x00"),LOG_REV_AUTHOR_NAME);\r
 440                 format += log;\r
 441                 log.Format(_T("#<%c>%%ae%%x00"),LOG_REV_AUTHOR_EMAIL);\r
 442                 format += log;\r
 443                 log.Format(_T("#<%c>%%ai%%x00"),LOG_REV_AUTHOR_DATE);\r
 444                 format += log;\r
 445                 log.Format(_T("#<%c>%%cn%%x00"),LOG_REV_COMMIT_NAME);\r
 446                 format += log;\r
 447                 log.Format(_T("#<%c>%%ce%%x00"),LOG_REV_COMMIT_EMAIL);\r
 448                 format += log;\r
 449                 log.Format(_T("#<%c>%%ci%%x00"),LOG_REV_COMMIT_DATE);\r
 450                 format += log;\r
 451                 log.Format(_T("#<%c>%%b%%x00"),LOG_REV_COMMIT_BODY);\r
 452                 format += log;\r
 453         }\r
 454         \r
 455         log.Format(_T("#<%c>%%m%%H%%x00"),LOG_REV_COMMIT_HASH);\r
 456         format += log;\r
 457         log.Format(_T("#<%c>%%P%%x00"),LOG_REV_COMMIT_PARENT);\r
 458         format += log;\r
 459         log.Format(_T("#<%c>%%s%%x00"),LOG_REV_COMMIT_SUBJECT);\r
 460         format += log;\r
 461 \r
 462         if(IsFull)\r
 463         {\r
 464                 log.Format(_T("#<%c>%%x00"),LOG_REV_COMMIT_FILE);\r
 465                 format += log;\r
 466         }\r
 467         return 0;\r
 468 }\r
 469 \r
 470 int CGit::GetLog(BYTE_VECTOR& logOut, CString &hash,  CTGitPath *path ,int count,int mask,CString *from,CString *to)\r
 471 {\r
 472         CGitCall_ByteVector gitCall(CString(),&logOut);\r
 473         return GetLog(&gitCall,hash,path,count,mask,from,to);\r
 474 }\r
 475 \r
 476 CString CGit::GetLogCmd( CString &hash, CTGitPath *path, int count, int mask,CString *from,CString *to,bool paramonly)\r
 477 {\r
 478         CString cmd;\r
 479         CString log;\r
 480         CString num;\r
 481         CString since;\r
 482 \r
 483         CString file;\r
 484 \r
 485         if(path)\r
 486                 file.Format(_T(" -- \"%s\""),path->GetGitPathString());\r
 487         \r
 488         if(count>0)\r
 489                 num.Format(_T("-n%d"),count);\r
 490 \r
 491         CString param;\r
 492 \r
 493         if(mask& LOG_INFO_STAT )\r
 494                 param += _T(" --numstat ");\r
 495         if(mask& LOG_INFO_FILESTATE)\r
 496                 param += _T(" --raw ");\r
 497 \r
 498         if(mask& LOG_INFO_FULLHISTORY)\r
 499                 param += _T(" --full-history ");\r
 500 \r
 501         if(mask& LOG_INFO_BOUNDARY)\r
 502                 param += _T(" --left-right --boundary ");\r
 503 \r
 504         if(mask& CGit::LOG_INFO_ALL_BRANCH)\r
 505                 param += _T(" --all ");\r
 506 \r
 507         if(mask& CGit::LOG_INFO_DETECT_COPYRENAME)\r
 508                 param += _T(" -C ");\r
 509         \r
 510         if(mask& CGit::LOG_INFO_DETECT_RENAME )\r
 511                 param += _T(" -M ");\r
 512 \r
 513         if(mask& CGit::LOG_INFO_FIRST_PARENT )\r
 514                 param += _T(" --first-parent ");\r
 515         \r
 516         if(mask& CGit::LOG_INFO_NO_MERGE )\r
 517                 param += _T(" --no-merges ");\r
 518 \r
 519         if(mask& CGit::LOG_INFO_FOLLOW)\r
 520                 param += _T(" --follow ");\r
 521 \r
 522         if(mask& CGit::LOG_INFO_SHOW_MERGEDFILE)\r
 523                 param += _T(" -c ");\r
 524 \r
 525         if(mask& CGit::LOG_INFO_FULL_DIFF)\r
 526                 param += _T(" --full-diff ");\r
 527 \r
 528         if(from != NULL && to != NULL)\r
 529         {\r
 530                 CString range;\r
 531                 range.Format(_T(" %s..%s "),*from,*to);\r
 532                 param += range;\r
 533         }\r
 534         param+=hash;\r
 535 \r
 536         if(paramonly)\r
 537                 cmd.Format(_T("%s -z --topo-order %s --parents "),\r
 538                                 num,param);\r
 539         else\r
 540                 cmd.Format(_T("git.exe log %s -z --topo-order %s --parents --pretty=format:\""),\r
 541                                 num,param);\r
 542 \r
 543         BuildOutputFormat(log,!(mask&CGit::LOG_INFO_ONLY_HASH));\r
 544 \r
 545         if(paramonly)\r
 546         {\r
 547                 cmd += hash+file;\r
 548         }else\r
 549         {\r
 550                 cmd += log;\r
 551                 cmd += CString(_T("\"  "))+hash+file;\r
 552         }\r
 553 \r
 554         return cmd;\r
 555 }\r
 556 //int CGit::GetLog(CGitCall* pgitCall, CString &hash,  CTGitPath *path ,int count,int mask)\r
 557 int CGit::GetLog(CGitCall* pgitCall, CString &hash, CTGitPath *path, int count, int mask,CString *from,CString *to)\r
 558 {\r
 559         pgitCall->SetCmd( GetLogCmd(hash,path,count,mask,from,to) );\r
 560 \r
 561         return Run(pgitCall);\r
 562 //      return Run(cmd,&logOut);\r
 563 }\r
 564 \r
 565 #define BUFSIZE 512\r
 566 void GetTempPath(CString &path)\r
 567 {\r
 568         TCHAR lpPathBuffer[BUFSIZE];\r
 569         DWORD dwRetVal;\r
 570         DWORD dwBufSize=BUFSIZE;\r
 571         dwRetVal = GetTempPath(dwBufSize,     // length of the buffer\r
 572                            lpPathBuffer); // buffer for path \r
 573     if (dwRetVal > dwBufSize || (dwRetVal == 0))\r
 574     {\r
 575         path=_T("");\r
 576     }\r
 577         path.Format(_T("%s"),lpPathBuffer);\r
 578 }\r
 579 CString GetTempFile()\r
 580 {\r
 581         TCHAR lpPathBuffer[BUFSIZE];\r
 582         DWORD dwRetVal;\r
 583     DWORD dwBufSize=BUFSIZE;\r
 584         TCHAR szTempName[BUFSIZE];  \r
 585         UINT uRetVal;\r
 586 \r
 587         dwRetVal = GetTempPath(dwBufSize,     // length of the buffer\r
 588                            lpPathBuffer); // buffer for path \r
 589     if (dwRetVal > dwBufSize || (dwRetVal == 0))\r
 590     {\r
 591         return _T("");\r
 592     }\r
 593          // Create a temporary file. \r
 594     uRetVal = GetTempFileName(lpPathBuffer, // directory for tmp files\r
 595                               TEXT("Patch"),  // temp file name prefix \r
 596                               0,            // create unique name \r
 597                               szTempName);  // buffer for name \r
 598 \r
 599 \r
 600     if (uRetVal == 0)\r
 601     {\r
 602         return _T("");\r
 603     }\r
 604 \r
 605         return CString(szTempName);\r
 606 \r
 607 }\r
 608 \r
 609 int CGit::RunLogFile(CString cmd,CString &filename)\r
 610 {\r
 611         STARTUPINFO si;\r
 612         PROCESS_INFORMATION pi;\r
 613         si.cb=sizeof(STARTUPINFO);\r
 614         GetStartupInfo(&si);\r
 615 \r
 616         SECURITY_ATTRIBUTES   psa={sizeof(psa),NULL,TRUE};;   \r
 617         psa.bInheritHandle=TRUE;   \r
 618     \r
 619         HANDLE   houtfile=CreateFile(filename,GENERIC_WRITE,FILE_SHARE_READ   |   FILE_SHARE_WRITE,   \r
 620                         &psa,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);   \r
 621 \r
 622 \r
 623         si.wShowWindow=SW_HIDE;\r
 624         si.dwFlags=STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;\r
 625         si.hStdOutput   =   houtfile; \r
 626         \r
 627         if(!CreateProcess(NULL,(LPWSTR)cmd.GetString(), NULL,NULL,TRUE,NULL,NULL,(LPWSTR)m_CurrentDir.GetString(),&si,&pi))\r
 628         {\r
 629                 LPVOID lpMsgBuf;\r
 630                 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,\r
 631                         NULL,GetLastError(),MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),\r
 632                         (LPTSTR)&lpMsgBuf,\r
 633                         0,NULL);\r
 634                 return GIT_ERROR_CREATE_PROCESS;\r
 635         }\r
 636         \r
 637         WaitForSingleObject(pi.hProcess,INFINITE);   \r
 638         \r
 639         CloseHandle(pi.hThread);\r
 640         CloseHandle(pi.hProcess);\r
 641         CloseHandle(houtfile);\r
 642         return GIT_SUCCESS;\r
 643 //      return 0;\r
 644 }\r
 645 \r
 646 git_revnum_t CGit::GetHash(const CString &friendname)\r
 647 {\r
 648         CString cmd;\r
 649         CString out;\r
 650         cmd.Format(_T("git.exe rev-parse %s" ),friendname);\r
 651         Run(cmd,&out,CP_UTF8);\r
 652 //      int pos=out.ReverseFind(_T('\n'));\r
 653         int pos=out.FindOneOf(_T("\r\n"));\r
 654         if(pos>0)\r
 655                 return out.Left(pos);\r
 656         return out;\r
 657 }\r
 658 \r
 659 int CGit::GetCommitDiffList(CString &rev1,CString &rev2,CTGitPathList &outputlist)\r
 660 {\r
 661         CString cmd;\r
 662         \r
 663         if(rev1 == GIT_REV_ZERO || rev2 == GIT_REV_ZERO)\r
 664         {\r
 665                 //rev1=+_T("");\r
 666                 if(rev1 == GIT_REV_ZERO)\r
 667                         cmd.Format(_T("git.exe diff -r --raw -C -M --numstat -z %s"),rev2);\r
 668                 else\r
 669                         cmd.Format(_T("git.exe diff -r -R --raw -C -M --numstat -z %s"),rev1);\r
 670         }else\r
 671         {\r
 672                 cmd.Format(_T("git.exe diff-tree -r --raw -C -M --numstat -z %s %s"),rev2,rev1);\r
 673         }\r
 674 \r
 675         BYTE_VECTOR out;\r
 676         if(g_Git.Run(cmd,&out))\r
 677                 return -1;\r
 678 \r
 679         outputlist.ParserFromLog(out);\r
 680 \r
 681 }\r
 682 \r
 683 int CGit::GetTagList(STRING_VECTOR &list)\r
 684 {\r
 685         int ret;\r
 686         CString cmd,output;\r
 687         cmd=_T("git.exe tag -l");\r
 688         int i=0;\r
 689         ret=g_Git.Run(cmd,&output,CP_UTF8);\r
 690         if(!ret)\r
 691         {               \r
 692                 int pos=0;\r
 693                 CString one;\r
 694                 while( pos>=0 )\r
 695                 {\r
 696                         i++;\r
 697                         one=output.Tokenize(_T("\n"),pos);\r
 698                         list.push_back(one);\r
 699                 }\r
 700         }\r
 701         return ret;\r
 702 }\r
 703 \r
 704 int CGit::GetBranchList(STRING_VECTOR &list,int *current,BRANCH_TYPE type)\r
 705 {\r
 706         int ret;\r
 707         CString cmd,output;\r
 708         cmd=_T("git.exe branch --no-color");\r
 709 \r
 710         if(type==(BRANCH_LOCAL|BRANCH_REMOTE))\r
 711                 cmd+=_T(" -a");\r
 712         else if(type==BRANCH_REMOTE)\r
 713                 cmd+=_T(" -r");\r
 714 \r
 715         int i=0;\r
 716         ret=g_Git.Run(cmd,&output,CP_UTF8);\r
 717         if(!ret)\r
 718         {               \r
 719                 int pos=0;\r
 720                 CString one;\r
 721                 while( pos>=0 )\r
 722                 {\r
 723                         one=output.Tokenize(_T("\n"),pos);\r
 724                         one.Trim(L" \r\n\t");\r
 725                         if(one.Find(L" -> ") >= 0 || one.IsEmpty())\r
 726                                 continue; // skip something like: refs/origin/HEAD -> refs/origin/master\r
 727                         if(one[0] == _T('*'))\r
 728                         {\r
 729                                 if(current)\r
 730                                         *current=i;\r
 731                                 one = one.Mid(2);\r
 732                         }\r
 733                         list.push_back(one);\r
 734                         i++;\r
 735                 }\r
 736         }\r
 737         return ret;\r
 738 }\r
 739 \r
 740 int CGit::GetRemoteList(STRING_VECTOR &list)\r
 741 {\r
 742         int ret;\r
 743         CString cmd,output;\r
 744         cmd=_T("git.exe config  --get-regexp \"^^remote[.].*[.]url\"");\r
 745         ret=g_Git.Run(cmd,&output,CP_UTF8);\r
 746         if(!ret)\r
 747         {\r
 748                 int pos=0;\r
 749                 CString one;\r
 750                 while( pos>=0 )\r
 751                 {\r
 752                         one=output.Tokenize(_T("\n"),pos);\r
 753                         int start=one.Find(_T("."),0);\r
 754                         if(start>0)\r
 755                         {\r
 756                                 CString url;\r
 757                                 url=one.Right(one.GetLength()-start-1);\r
 758                                 one=url;\r
 759                                 one=one.Left(one.Find(_T("."),0));\r
 760                                 list.push_back(one);\r
 761                         }\r
 762                 }\r
 763         }\r
 764         return ret;\r
 765 }\r
 766 \r
 767 int CGit::GetRefList(STRING_VECTOR &list)\r
 768 {\r
 769         int ret;\r
 770         CString cmd,output;\r
 771         cmd=_T("git show-ref -d");\r
 772         ret=g_Git.Run(cmd,&output,CP_UTF8);\r
 773         if(!ret)\r
 774         {\r
 775                 int pos=0;\r
 776                 CString one;\r
 777                 while( pos>=0 )\r
 778                 {\r
 779                         one=output.Tokenize(_T("\n"),pos);\r
 780                         int start=one.Find(_T(" "),0);\r
 781                         if(start>0)\r
 782                         {\r
 783                                 CString name;\r
 784                                 name=one.Right(one.GetLength()-start-1);\r
 785                                 list.push_back(name);\r
 786                         }\r
 787                 }\r
 788         }\r
 789         return ret;\r
 790 }\r
 791 int CGit::GetMapHashToFriendName(MAP_HASH_NAME &map)\r
 792 {\r
 793         int ret;\r
 794         CString cmd,output;\r
 795         cmd=_T("git show-ref -d");\r
 796         ret=g_Git.Run(cmd,&output,CP_UTF8);\r
 797         if(!ret)\r
 798         {\r
 799                 int pos=0;\r
 800                 CString one;\r
 801                 while( pos>=0 )\r
 802                 {\r
 803                         one=output.Tokenize(_T("\n"),pos);\r
 804                         int start=one.Find(_T(" "),0);\r
 805                         if(start>0)\r
 806                         {\r
 807                                 CString name;\r
 808                                 name=one.Right(one.GetLength()-start-1);\r
 809 \r
 810                                 CString hash;\r
 811                                 hash=one.Left(start);\r
 812 \r
 813                                 map[hash].push_back(name);\r
 814                         }\r
 815                 }\r
 816         }\r
 817         return ret;\r
 818 }\r
 819 \r
 820 BOOL CGit::CheckMsysGitDir()\r
 821 {\r
 822         static BOOL bInitialized = FALSE;\r
 823 \r
 824         if (bInitialized)\r
 825         {\r
 826                 return TRUE;\r
 827         }\r
 828 \r
 829         TCHAR *oldpath,*home;\r
 830         size_t homesize,size,httpsize;\r
 831 \r
 832         // set HOME if not set already\r
 833         _tgetenv_s(&homesize, NULL, 0, _T("HOME"));\r
 834         if (!homesize)\r
 835         {\r
 836                 _tdupenv_s(&home,&size,_T("USERPROFILE")); \r
 837                 _tputenv_s(_T("HOME"),home);\r
 838                 free(home);\r
 839         }\r
 840         CString str;\r
 841 \r
 842 #ifndef _TORTOISESHELL\r
 843         //set http_proxy\r
 844         _tgetenv_s(&httpsize, NULL, 0, _T("http_proxy"));\r
 845         if (!httpsize)\r
 846         {\r
 847                 CString regServeraddress_copy = CRegString(_T("Software\\TortoiseGit\\Servers\\global\\http-proxy-host"), _T(""));\r
 848                 CString regServerport_copy = CRegString(_T("Software\\TortoiseGit\\Servers\\global\\http-proxy-port"), _T(""));\r
 849                 CString regUsername_copy = CRegString(_T("Software\\TortoiseGit\\Servers\\global\\http-proxy-username"), _T(""));\r
 850                 CString regPassword_copy = CRegString(_T("Software\\TortoiseGit\\Servers\\global\\http-proxy-password"), _T(""));\r
 851                 CString regTimeout_copy = CRegString(_T("Software\\TortoiseGit\\Servers\\global\\http-proxy-timeout"), _T(""));\r
 852                 CString regExceptions_copy = CRegString(_T("Software\\TortoiseGit\\Servers\\global\\http-proxy-exceptions"), _T(""));\r
 853 \r
 854                 CString http_proxy;\r
 855                 if(!regServeraddress_copy.IsEmpty())\r
 856                 {\r
 857                         if(regServeraddress_copy.Left(4) != _T("http"))\r
 858                                 http_proxy=_T("http://");\r
 859 \r
 860                         if(!regUsername_copy.IsEmpty())\r
 861                         {\r
 862                                 http_proxy += regUsername_copy;\r
 863                                 http_proxy += _T(":")+regPassword_copy;\r
 864                                 http_proxy += _T("@");\r
 865                         }\r
 866                         http_proxy+=regServeraddress_copy;\r
 867                         if(!regServerport_copy.IsEmpty())\r
 868                         {\r
 869                                 http_proxy +=_T(":")+regServerport_copy;\r
 870                         }\r
 871                         _tputenv_s(_T("http_proxy"),http_proxy);\r
 872                 }\r
 873         }\r
 874         //setup ssh client\r
 875         CString sshclient=CRegString(_T("Software\\TortoiseGit\\SSH"));\r
 876 \r
 877         if(!sshclient.IsEmpty())\r
 878         {\r
 879                 _tputenv_s(_T("GIT_SSH"),sshclient);\r
 880                 \r
 881                 //Setup SVN_SSH\r
 882                 CString ssh=sshclient;\r
 883                 ssh.Replace(_T("/"),_T("\\"));\r
 884                 ssh.Replace(_T("\\"),_T("\\\\"));\r
 885                 ssh=CString(_T("\""))+ssh+_T('\"');\r
 886                 _tputenv_s(_T("SVN_SSH"),ssh);\r
 887 \r
 888         }else\r
 889         {\r
 890                 TCHAR sPlink[MAX_PATH];\r
 891                 GetModuleFileName(NULL, sPlink, _countof(sPlink));\r
 892                 LPTSTR ptr = _tcsrchr(sPlink, _T('\\'));\r
 893                 if (ptr) {\r
 894                         _tcscpy(ptr + 1, _T("TortoisePlink.exe"));\r
 895                         _tputenv_s(_T("GIT_SSH"), sPlink);\r
 896 \r
 897                         //Setup SVN_SSH\r
 898                         CString ssh=sPlink;\r
 899                         ssh.Replace(_T("/"),_T("\\"));\r
 900                         ssh.Replace(_T("\\"),_T("\\\\"));\r
 901                         ssh=CString(_T("\""))+ssh+_T('\"');\r
 902                         _tputenv_s(_T("SVN_SSH"),ssh);\r
 903                 }\r
 904         }\r
 905 \r
 906         {\r
 907                 TCHAR sAskPass[MAX_PATH];\r
 908                 GetModuleFileName(NULL, sAskPass, _countof(sAskPass));\r
 909                 LPTSTR ptr = _tcsrchr(sAskPass, _T('\\'));\r
 910                 if (ptr) \r
 911                 {\r
 912                         _tcscpy(ptr + 1, _T("SshAskPass.exe"));\r
 913                         _tputenv_s(_T("DISPLAY"),_T(":9999"));\r
 914                         _tputenv_s(_T("SSH_ASKPASS"),sAskPass);\r
 915                 }\r
 916         }\r
 917         // search PATH if git/bin directory is alredy present\r
 918         if ( FindGitPath() )\r
 919         {\r
 920                 bInitialized = TRUE;\r
 921                 return TRUE;\r
 922         }\r
 923 \r
 924         // add git/bin path to PATH\r
 925 \r
 926         CRegString msysdir=CRegString(REG_MSYSGIT_PATH,_T(""),FALSE);\r
 927         str=msysdir;\r
 928         if(str.IsEmpty())\r
 929         {\r
 930                 CRegString msysinstalldir=CRegString(REG_MSYSGIT_INSTALL,_T(""),FALSE,HKEY_LOCAL_MACHINE);\r
 931                 str=msysinstalldir;\r
 932                 if ( !str.IsEmpty() )\r
 933                 {\r
 934                         str += (str[str.GetLength()-1] != '\\') ? "\\bin" : "bin";\r
 935                         msysdir=str;\r
 936                         msysdir.write();\r
 937                 }\r
 938                 else\r
 939                 {\r
 940                         return false;\r
 941                 }\r
 942         }\r
 943 #endif\r
 944         //CGit::m_MsysGitPath=str;\r
 945 \r
 946         //set path\r
 947 \r
 948         _tdupenv_s(&oldpath,&size,_T("PATH")); \r
 949 \r
 950         CString path;\r
 951         path.Format(_T("%s;%s"),oldpath,str);\r
 952 \r
 953         _tputenv_s(_T("PATH"),path);\r
 954 \r
 955         CString sOldPath = oldpath;\r
 956         free(oldpath);\r
 957 \r
 958 \r
 959     if( !FindGitPath() )\r
 960         {\r
 961                 if(!homesize)\r
 962                 {\r
 963                         _tputenv_s(_T("HOME"),_T(""));\r
 964                 }\r
 965                 return false;\r
 966         }\r
 967         else\r
 968         {\r
 969 #ifdef _TORTOISESHELL\r
 970                 l_processEnv = GetEnvironmentStrings();\r
 971                 // updated environment is now duplicated for use in CreateProcess, restore original PATH for current process\r
 972                 _tputenv_s(_T("PATH"),sOldPath);\r
 973                 if(!homesize)\r
 974                 {\r
 975                         _tputenv_s(_T("HOME"),_T(""));\r
 976                 }\r
 977 #endif\r
 978 \r
 979                 bInitialized = TRUE;\r
 980                 return true;\r
 981         }\r
 982 }\r
 983 \r
 984 \r
 985 class CGitCall_EnumFiles : public CGitCall\r
 986 {\r
 987 public:\r
 988         CGitCall_EnumFiles(const TCHAR *pszProjectPath, const TCHAR *pszSubPath, unsigned int nFlags, WGENUMFILECB *pEnumCb, void *pUserData)\r
 989         :       m_pszProjectPath(pszProjectPath),\r
 990                 m_pszSubPath(pszSubPath),\r
 991                 m_nFlags(nFlags),\r
 992                 m_pEnumCb(pEnumCb),\r
 993                 m_pUserData(pUserData)\r
 994         {\r
 995         }\r
 996 \r
 997         typedef std::map<CStringA,char> TStrCharMap;\r
 998 \r
 999         const TCHAR *   m_pszProjectPath;\r
1000         const TCHAR *   m_pszSubPath;\r
1001         unsigned int    m_nFlags;\r
1002         WGENUMFILECB *  m_pEnumCb;\r
1003         void *                  m_pUserData;\r
1004 \r
1005         BYTE_VECTOR             m_DataCollector;\r
1006 \r
1007         virtual bool    OnOutputData(const BYTE* data, size_t size)\r
1008         {\r
1009                 m_DataCollector.append(data,size);\r
1010                 while(true)\r
1011                 {\r
1012                         // lines from igit.exe are 0 terminated\r
1013                         int found=m_DataCollector.findData((const BYTE*)"",1);\r
1014                         if(found<0)\r
1015                                 return false;\r
1016                         OnSingleLine( (LPCSTR)&*m_DataCollector.begin() );\r
1017                         m_DataCollector.erase(m_DataCollector.begin(), m_DataCollector.begin()+found+1);\r
1018                 }\r
1019                 return false;//Should never reach this\r
1020         }\r
1021         virtual void    OnEnd()\r
1022         {\r
1023         }\r
1024 \r
1025         BYTE HexChar(char ch)\r
1026         {\r
1027                 if (ch >= '0' && ch <= '9')\r
1028                         return (UINT)(ch - '0');\r
1029                 else if (ch >= 'A' && ch <= 'F')\r
1030                         return (UINT)(ch - 'A') + 10;\r
1031                 else if (ch >= 'a' && ch <= 'f')\r
1032                         return (UINT)(ch - 'a') + 10;\r
1033                 else\r
1034                         return 0;\r
1035         }\r
1036 \r
1037         bool OnSingleLine(LPCSTR line)\r
1038         {\r
1039                 //Parse single line\r
1040 \r
1041                 wgFile_s fileStatus;\r
1042 \r
1043                 // file/dir type\r
1044 \r
1045                 fileStatus.nFlags = 0;\r
1046                 if (*line == 'D')\r
1047                         fileStatus.nFlags |= WGFF_Directory;\r
1048                 else if (*line != 'F')\r
1049                         // parse error\r
1050                         return false;\r
1051                 line += 2;\r
1052 \r
1053                 // status\r
1054 \r
1055                 fileStatus.nStatus = WGFS_Unknown;\r
1056                 switch (*line)\r
1057                 {\r
1058                 case 'N': fileStatus.nStatus = WGFS_Normal; break;\r
1059                 case 'M': fileStatus.nStatus = WGFS_Modified; break;\r
1060                 case 'S': fileStatus.nStatus = WGFS_Staged; break;\r
1061                 case 'A': fileStatus.nStatus = WGFS_Added; break;\r
1062                 case 'C': fileStatus.nStatus = WGFS_Conflicted; break;\r
1063                 case 'D': fileStatus.nStatus = WGFS_Deleted; break;\r
1064                 case 'I': fileStatus.nStatus = WGFS_Ignored; break;\r
1065                 case 'U': fileStatus.nStatus = WGFS_Unversioned; break;\r
1066                 case 'E': fileStatus.nStatus = WGFS_Empty; break;\r
1067                 case '?': fileStatus.nStatus = WGFS_Unknown; break;\r
1068                 default:\r
1069                         // parse error\r
1070                         return false;\r
1071                 }\r
1072                 line += 2;\r
1073 \r
1074                 // file sha1\r
1075 \r
1076                 BYTE sha1[20];\r
1077                 fileStatus.sha1 = NULL;\r
1078                 if ( !(fileStatus.nFlags & WGFF_Directory) )\r
1079                 {\r
1080                         for (int i=0; i<20; i++)\r
1081                         {\r
1082                                 sha1[i]  = (HexChar(line[0])<<4)&0xF0;\r
1083                                 sha1[i] |= HexChar(line[1])&0xF;\r
1084 \r
1085                                 line += 2;\r
1086                         }\r
1087 \r
1088                         line++;\r
1089                 }\r
1090 \r
1091                 // filename\r
1092                 int len = strlen(line);\r
1093                 if (len && len < 2048)\r
1094                 {\r
1095                         WCHAR *buf = (WCHAR*)alloca((len*4+2)*sizeof(WCHAR));\r
1096                         *buf = 0;\r
1097                         MultiByteToWideChar(CP_ACP, 0, line, len+1, buf, len*4+1);\r
1098                         fileStatus.sFileName = buf;\r
1099 \r
1100                         if (*buf && (*m_pEnumCb)(&fileStatus,m_pUserData))\r
1101                                 return false;\r
1102                 }\r
1103 \r
1104                 return true;\r
1105         }\r
1106 };\r
1107 \r
1108 BOOL CGit::EnumFiles(const TCHAR *pszProjectPath, const TCHAR *pszSubPath, unsigned int nFlags, WGENUMFILECB *pEnumCb, void *pUserData)\r
1109 {\r
1110         if(!pszProjectPath || *pszProjectPath=='\0')\r
1111                 return FALSE;\r
1112 \r
1113         CGitCall_EnumFiles W_GitCall(pszProjectPath,pszSubPath,nFlags,pEnumCb,pUserData);\r
1114         CString cmd;\r
1115 \r
1116 /*      char W_szToDir[MAX_PATH];\r
1117         strncpy(W_szToDir,pszProjectPath,sizeof(W_szToDir)-1);\r
1118         if(W_szToDir[strlen(W_szToDir)-1]!='\\')\r
1119                 strncat(W_szToDir,"\\",sizeof(W_szToDir)-1);\r
1120 \r
1121         SetCurrentDirectoryA(W_szToDir);\r
1122         GetCurrentDirectoryA(sizeof(W_szToDir)-1,W_szToDir);\r
1123 */\r
1124         SetCurrentDir(pszProjectPath);\r
1125 \r
1126         CString sMode;\r
1127         if (nFlags)\r
1128         {\r
1129                 if (nFlags & WGEFF_NoRecurse) sMode += _T("r");\r
1130                 if (nFlags & WGEFF_FullPath) sMode += _T("f");\r
1131                 if (nFlags & WGEFF_DirStatusDelta) sMode += _T("d");\r
1132                 if (nFlags & WGEFF_DirStatusAll) sMode += _T("D");\r
1133                 if (nFlags & WGEFF_EmptyAsNormal) sMode += _T("e");\r
1134                 if (nFlags & WGEFF_SingleFile) sMode += _T("s");\r
1135         }\r
1136         else\r
1137         {\r
1138                 sMode = _T("-");\r
1139         }\r
1140 \r
1141         // NOTE: there seems to be some issue with msys based app receiving backslash on commandline, at least\r
1142         // if followed by " like for example 'igit "C:\"', the commandline igit receives is 'igit.exe C:" status' with\r
1143         // the 'C:" status' part as a single arg, Maybe it uses unix style processing. In order to avoid this just\r
1144         // use forward slashes for supplied project and sub paths\r
1145 \r
1146         CString sProjectPath = pszProjectPath;\r
1147         sProjectPath.Replace(_T('\\'), _T('/'));\r
1148 \r
1149         if (pszSubPath)\r
1150         {\r
1151                 CString sSubPath = pszSubPath;\r
1152                 sSubPath.Replace(_T('\\'), _T('/'));\r
1153 \r
1154                 cmd.Format(_T("tgit.exe statusex \"%s\" status %s \"%s\""), sProjectPath, sMode, sSubPath);\r
1155         }\r
1156         else\r
1157         {\r
1158                 cmd.Format(_T("tgit.exe statusex \"%s\" status %s"), sProjectPath, sMode);\r
1159         }\r
1160 \r
1161         //OutputDebugStringA("---");OutputDebugStringW(cmd);OutputDebugStringA("\r\n");\r
1162 \r
1163         W_GitCall.SetCmd(cmd);\r
1164         // NOTE: should igit get added as a part of msysgit then use below line instead of the above one\r
1165         //W_GitCall.SetCmd(CGit::ms_LastMsysGitDir + cmd);\r
1166 \r
1167         if ( Run(&W_GitCall) )\r
1168                 return FALSE;\r
1169 \r
1170         return TRUE;\r
1171 }\r
1172 \r
1173 BOOL CGit::CheckCleanWorkTree()\r
1174 {\r
1175         CString out;\r
1176         CString cmd;\r
1177         cmd=_T("git.exe rev-parse --verify HEAD");\r
1178 \r
1179         if(g_Git.Run(cmd,&out,CP_UTF8))\r
1180                 return FALSE;\r
1181 \r
1182         cmd=_T("git.exe update-index --ignore-submodules --refresh");\r
1183         if(g_Git.Run(cmd,&out,CP_UTF8))\r
1184                 return FALSE;\r
1185 \r
1186         cmd=_T("git.exe diff-files --quiet --ignore-submodules");\r
1187         if(g_Git.Run(cmd,&out,CP_UTF8))\r
1188                 return FALSE;\r
1189 \r
1190         cmd=_T("git diff-index --cached --quiet HEAD --ignore-submodules");\r
1191         if(g_Git.Run(cmd,&out,CP_UTF8))\r
1192                 return FALSE;\r
1193 \r
1194         return TRUE;\r
1195 }\r
1196 int CGit::Revert(CTGitPathList &list,bool keep)\r
1197 {\r
1198         int ret;\r
1199         for(int i=0;i<list.GetCount();i++)\r
1200         {       \r
1201                 ret = Revert((CTGitPath&)list[i],keep);\r
1202                 if(ret)\r
1203                         return ret;\r
1204         }\r
1205         return 0;\r
1206 }\r
1207 int CGit::Revert(CTGitPath &path,bool keep)\r
1208 {\r
1209         CString cmd, out;\r
1210         if(path.m_Action & CTGitPath::LOGACTIONS_ADDED)\r
1211         {       //To init git repository, there are not HEAD, so we can use git reset command\r
1212                 cmd.Format(_T("git.exe rm --cached -- \"%s\""),path.GetGitPathString());\r
1213 \r
1214                 if(g_Git.Run(cmd,&out,CP_ACP))\r
1215                         return -1;\r
1216         }\r
1217         else if(path.m_Action & CTGitPath::LOGACTIONS_REPLACED )\r
1218         {\r
1219                 cmd.Format(_T("git.exe mv -- \"%s\" \"%s\""),path.GetGitPathString(),path.GetGitOldPathString());\r
1220                 if(g_Git.Run(cmd,&out,CP_ACP))\r
1221                         return -1;\r
1222                 \r
1223                 cmd.Format(_T("git.exe checkout HEAD -f -- \"%s\""),path.GetGitOldPathString());\r
1224                 if(g_Git.Run(cmd,&out,CP_ACP))\r
1225                         return -1;\r
1226         }\r
1227         else\r
1228         {\r
1229                 cmd.Format(_T("git.exe checkout HEAD -f -- \"%s\""),path.GetGitPathString());\r
1230                 if(g_Git.Run(cmd,&out,CP_ACP))\r
1231                         return -1;\r
1232         }\r
1233         return 0;\r
1234 }\r
1235 \r
1236 int CGit::ListConflictFile(CTGitPathList &list,CTGitPath *path)\r
1237 {\r
1238         BYTE_VECTOR vector;\r
1239 \r
1240         CString cmd;\r
1241         if(path)\r
1242                 cmd.Format(_T("git.exe ls-files -u -t -z -- \"%s\""),path->GetGitPathString());\r
1243         else\r
1244                 cmd=_T("git.exe ls-files -u -t -z");\r
1245 \r
1246         if(g_Git.Run(cmd,&vector))\r
1247         {\r
1248                 return -1;\r
1249         }\r
1250 \r
1251         list.ParserFromLsFile(vector);\r
1252 \r
1253         return 0;\r
1254 }\r
1255 \r
1256 bool CGit::IsFastForward(CString &from, CString &to)\r
1257 {\r
1258         CString base,hash;\r
1259         CString cmd;\r
1260         cmd.Format(_T("git.exe merge-base %s %s"), to,from);\r
1261 \r
1262         if(g_Git.Run(cmd,&base,CP_ACP))\r
1263         {\r
1264                 //CMessageBox::Show(NULL,base,_T("TortoiseGit"),MB_OK|MB_ICONERROR);\r
1265                 return false;\r
1266         }\r
1267         base=base.Left(40);\r
1268 \r
1269         hash=g_Git.GetHash(from);\r
1270 \r
1271         hash=hash.Left(40);\r
1272         \r
1273         return hash == base;\r
1274 }\r
1275 \r
1276 unsigned int CGit::Hash2int(CString &hash)\r
1277 {\r
1278         int ret=0;\r
1279         for(int i=0;i<8;i++)\r
1280         {\r
1281                 ret =ret <<4;\r
1282                 if(hash[i]>=_T('a'))\r
1283                         ret |= (hash[i]-_T('a')+10)&0xFF;\r
1284                 else if(hash[i]>=_T('A'))\r
1285                         ret |= (hash[i]-_T('A')+10)&0xFF;\r
1286                 else\r
1287                         ret |= (hash[i]-_T('0'))&0xFF;          \r
1288                 \r
1289         }\r
1290         return ret;\r
1291 }\r
1292 \r
1293 int CGit::RefreshGitIndex()\r
1294 {\r
1295         CString cmd,output;\r
1296         cmd=_T("git.exe update-index --refresh");\r
1297         return Run(cmd,&output,CP_ACP);\r
1298 }\r
1299 \r