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 \r
   8 \r
   9 static LPTSTR nextpath(LPCTSTR src, LPTSTR dst, UINT maxlen)\r
  10 {\r
  11         LPCTSTR orgsrc;\r
  12 \r
  13         while (*src == _T(';'))\r
  14                 src++;\r
  15 \r
  16         orgsrc = src;\r
  17 \r
  18         if (!--maxlen)\r
  19                 goto nullterm;\r
  20 \r
  21         while (*src && *src != _T(';'))\r
  22         {\r
  23                 if (*src != _T('"'))\r
  24                 {\r
  25                         *dst++ = *src++;\r
  26                         if (!--maxlen)\r
  27                         {\r
  28                                 orgsrc = src;\r
  29                                 goto nullterm;\r
  30                         }\r
  31                 }\r
  32                 else\r
  33                 {\r
  34                         src++;\r
  35                         while (*src && *src != _T('"'))\r
  36                         {\r
  37                                 *dst++ = *src++;\r
  38                                 if (!--maxlen)\r
  39                                 {\r
  40                                         orgsrc = src;\r
  41                                         goto nullterm;\r
  42                                 }\r
  43                         }\r
  44 \r
  45                         if (*src)\r
  46                                 src++;\r
  47                 }\r
  48         }\r
  49 \r
  50         while (*src == _T(';'))\r
  51                 src++;\r
  52 \r
  53 nullterm:\r
  54 \r
  55         *dst = 0;\r
  56 \r
  57         return (orgsrc != src) ? (LPTSTR)src : NULL;\r
  58 }\r
  59 \r
  60 static inline BOOL FileExists(LPCTSTR lpszFileName)\r
  61 {\r
  62         struct _stat st;\r
  63         return _tstat(lpszFileName, &st) == 0;\r
  64 }\r
  65 \r
  66 static BOOL FindGitPath()\r
  67 {\r
  68         size_t size;\r
  69         _tgetenv_s(&size, NULL, 0, _T("PATH"));\r
  70 \r
  71         if (!size)\r
  72         {\r
  73                 return FALSE;\r
  74         }\r
  75 \r
  76         TCHAR *env = (TCHAR*)alloca(size * sizeof(TCHAR));\r
  77         _tgetenv_s(&size, env, size, _T("PATH"));\r
  78 \r
  79         TCHAR buf[_MAX_PATH];\r
  80 \r
  81         // search in all paths defined in PATH\r
  82         while ((env = nextpath(env, buf, _MAX_PATH-1)) && *buf)\r
  83         {\r
  84                 TCHAR *pfin = buf + _tcslen(buf)-1;\r
  85 \r
  86                 // ensure trailing slash\r
  87                 if (*pfin != _T('/') && *pfin != _T('\\'))\r
  88                         _tcscpy(++pfin, _T("\\"));\r
  89 \r
  90                 const int len = _tcslen(buf);\r
  91 \r
  92                 if ((len + 7) < _MAX_PATH)\r
  93                         _tcscpy(pfin+1, _T("git.exe"));\r
  94                 else\r
  95                         break;\r
  96 \r
  97                 if ( FileExists(buf) )\r
  98                 {\r
  99                         // dir found\r
 100                         return TRUE;\r
 101                 }\r
 102         }\r
 103 \r
 104         return FALSE;\r
 105 }\r
 106 \r
 107 \r
 108 #define MAX_DIRBUFFER 1000\r
 109 #define CALL_OUTPUT_READ_CHUNK_SIZE 1024\r
 110 \r
 111 CString CGit::ms_LastMsysGitDir;\r
 112 CGit g_Git;\r
 113 BOOL g_IsWingitDllload = TRUE;\r
 114 \r
 115 LPBYTE wgGetRevisionID_safe(const char *pszProjectPath, const char *pszName)\r
 116 {\r
 117         if(g_IsWingitDllload)\r
 118                 return wgGetRevisionID(pszProjectPath,pszName);\r
 119         else\r
 120                 return NULL;\r
 121 }\r
 122 \r
 123 BOOL wgEnumFiles_safe(const char *pszProjectPath, const char *pszSubPath, unsigned int nFlags, WGENUMFILECB *pEnumCb, void *pUserData)\r
 124 {\r
 125         if(g_IsWingitDllload)\r
 126                 return wgEnumFiles(pszProjectPath,pszSubPath,nFlags,pEnumCb,pUserData);\r
 127         else\r
 128                 return FALSE;\r
 129 }\r
 130 \r
 131 BOOL CGit::IsVista()\r
 132 {\r
 133 \r
 134         if( CRegStdWORD(_T("Software\\TortoiseGit\\CacheType") ) == 0)\r
 135         {\r
 136                 g_IsWingitDllload=FALSE;\r
 137                 return TRUE;\r
 138         }\r
 139 \r
 140         OSVERSIONINFO osvi;\r
 141     BOOL bIsWindowsXPorLater;\r
 142 \r
 143     ZeroMemory(&osvi, sizeof(OSVERSIONINFO));\r
 144     osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);\r
 145 \r
 146     GetVersionEx(&osvi);\r
 147         \r
 148         if(osvi.dwMajorVersion >= 6)\r
 149                 return TRUE;\r
 150         else\r
 151                 return FALSE;\r
 152 }\r
 153 \r
 154 static void InitWinGitDll()\r
 155 {\r
 156         __try\r
 157         {\r
 158 \r
 159                 if( CGit::IsVista () )\r
 160                 {\r
 161                         g_IsWingitDllload=FALSE;\r
 162                         return;\r
 163                 }\r
 164                 if ( !wgInit() )\r
 165                 {\r
 166                                 // TODO\r
 167                 }\r
 168         }\r
 169         __except(1)\r
 170         {\r
 171                 g_IsWingitDllload=FALSE;\r
 172                 return;\r
 173         }\r
 174 \r
 175 }\r
 176 CGit::CGit(void)\r
 177 {\r
 178         GetCurrentDirectory(MAX_DIRBUFFER,m_CurrentDir.GetBuffer(MAX_DIRBUFFER));\r
 179         m_CurrentDir.ReleaseBuffer();\r
 180         // make sure git/bin is in PATH before wingit.dll gets (delay) loaded by wgInit()\r
 181         if ( !CheckMsysGitDir() )\r
 182         {\r
 183                 // TODO\r
 184         }\r
 185         InitWinGitDll();\r
 186 }\r
 187 \r
 188 CGit::~CGit(void)\r
 189 {\r
 190 }\r
 191 \r
 192 static char g_Buffer[4096];\r
 193 \r
 194 int CGit::RunAsync(CString cmd,PROCESS_INFORMATION *piOut,HANDLE *hReadOut,CString *StdioFile)\r
 195 {\r
 196         SECURITY_ATTRIBUTES sa;\r
 197         HANDLE hRead, hWrite;\r
 198         HANDLE hStdioFile = NULL;\r
 199 \r
 200         sa.nLength = sizeof(SECURITY_ATTRIBUTES);\r
 201         sa.lpSecurityDescriptor=NULL;\r
 202         sa.bInheritHandle=TRUE;\r
 203         if(!CreatePipe(&hRead,&hWrite,&sa,0))\r
 204         {\r
 205                 return GIT_ERROR_OPEN_PIP;\r
 206         }\r
 207         \r
 208         if(StdioFile)\r
 209         {\r
 210                 hStdioFile=CreateFile(*StdioFile,GENERIC_WRITE,FILE_SHARE_READ   |   FILE_SHARE_WRITE,   \r
 211                         &sa,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);  \r
 212         }\r
 213 \r
 214         STARTUPINFO si;\r
 215         PROCESS_INFORMATION pi;\r
 216         si.cb=sizeof(STARTUPINFO);\r
 217         GetStartupInfo(&si);\r
 218 \r
 219         si.hStdError=hWrite;\r
 220         if(StdioFile)\r
 221                 si.hStdOutput=hStdioFile;\r
 222         else\r
 223                 si.hStdOutput=hWrite;\r
 224 \r
 225         si.wShowWindow=SW_HIDE;\r
 226         si.dwFlags=STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;\r
 227 \r
 228         if(!CreateProcess(NULL,(LPWSTR)cmd.GetString(), NULL,NULL,TRUE,NULL,NULL,(LPWSTR)m_CurrentDir.GetString(),&si,&pi))\r
 229         {\r
 230                 LPVOID lpMsgBuf;\r
 231                 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,\r
 232                         NULL,GetLastError(),MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),\r
 233                         (LPTSTR)&lpMsgBuf,\r
 234                         0,NULL);\r
 235                 return GIT_ERROR_CREATE_PROCESS;\r
 236         }\r
 237         \r
 238         CloseHandle(hWrite);\r
 239         if(piOut)\r
 240                 *piOut=pi;\r
 241         if(hReadOut)\r
 242                 *hReadOut=hRead;\r
 243         \r
 244         return 0;\r
 245 \r
 246 }\r
 247 //Must use sperate function to convert ANSI str to union code string\r
 248 //Becuase A2W use stack as internal convert buffer. \r
 249 void CGit::StringAppend(CString *str,BYTE *p,int code,int length)\r
 250 {\r
 251      //USES_CONVERSION;\r
 252          //str->Append(A2W_CP((LPCSTR)p,code));\r
 253         WCHAR * buf;\r
 254 \r
 255         int len ;\r
 256         if(length<0)\r
 257                 len= strlen((const char*)p);\r
 258         else\r
 259                 len=length;\r
 260         //if (len==0)\r
 261         //      return ;\r
 262         //buf = new WCHAR[len*4 + 1];\r
 263         buf = str->GetBuffer(len*4+1+str->GetLength())+str->GetLength();\r
 264         SecureZeroMemory(buf, (len*4 + 1)*sizeof(WCHAR));\r
 265         MultiByteToWideChar(code, 0, (LPCSTR)p, len, buf, len*4);\r
 266         str->ReleaseBuffer();\r
 267         //str->Append(buf);\r
 268         //delete buf;\r
 269 }       \r
 270 BOOL CGit::IsInitRepos()\r
 271 {\r
 272         CString cmdout;\r
 273         cmdout.Empty();\r
 274         if(g_Git.Run(_T("git.exe rev-parse --revs-only HEAD"),&cmdout,CP_UTF8))\r
 275         {\r
 276         //      CMessageBox::Show(NULL,cmdout,_T("TortoiseGit"),MB_OK);\r
 277                 return TRUE;\r
 278         }\r
 279         if(cmdout.IsEmpty())\r
 280                 return TRUE;\r
 281 \r
 282         return FALSE;\r
 283 }\r
 284 int CGit::Run(CGitCall* pcall)\r
 285 {\r
 286         PROCESS_INFORMATION pi;\r
 287         HANDLE hRead;\r
 288         if(RunAsync(pcall->GetCmd(),&pi,&hRead))\r
 289                 return GIT_ERROR_CREATE_PROCESS;\r
 290 \r
 291         DWORD readnumber;\r
 292         BYTE data[CALL_OUTPUT_READ_CHUNK_SIZE];\r
 293         while(ReadFile(hRead,data,CALL_OUTPUT_READ_CHUNK_SIZE,&readnumber,NULL))\r
 294         {\r
 295                 pcall->OnOutputData(data,readnumber);\r
 296         }\r
 297 \r
 298         \r
 299         CloseHandle(pi.hThread);\r
 300 \r
 301         WaitForSingleObject(pi.hProcess, INFINITE);\r
 302         DWORD exitcode =0;\r
 303 \r
 304         if(!GetExitCodeProcess(pi.hProcess,&exitcode))\r
 305         {\r
 306                 return GIT_ERROR_GET_EXIT_CODE;\r
 307         }\r
 308 \r
 309         CloseHandle(pi.hProcess);\r
 310 \r
 311         CloseHandle(hRead);\r
 312         return exitcode;\r
 313 }\r
 314 class CGitCall_ByteVector : public CGitCall\r
 315 {\r
 316 public:\r
 317         CGitCall_ByteVector(CString cmd,BYTE_VECTOR* pvector):CGitCall(cmd),m_pvector(pvector){}\r
 318         virtual bool OnOutputData(const BYTE* data, size_t size)\r
 319         {\r
 320                 size_t oldsize=m_pvector->size();\r
 321                 m_pvector->resize(m_pvector->size()+size);\r
 322                 memcpy(&*(m_pvector->begin()+oldsize),data,size);\r
 323                 return false;\r
 324         }\r
 325         BYTE_VECTOR* m_pvector;\r
 326 \r
 327 };\r
 328 int CGit::Run(CString cmd,BYTE_VECTOR *vector)\r
 329 {\r
 330         CGitCall_ByteVector call(cmd,vector);\r
 331         return Run(&call);\r
 332 }\r
 333 int CGit::Run(CString cmd, CString* output,int code)\r
 334 {\r
 335         BYTE_VECTOR vector;\r
 336         int ret;\r
 337         ret=Run(cmd,&vector);\r
 338 \r
 339         vector.push_back(0);\r
 340         \r
 341         StringAppend(output,&(vector[0]),code);\r
 342         return ret;\r
 343 }\r
 344 \r
 345 CString CGit::GetUserName(void)\r
 346 {\r
 347         CString UserName;\r
 348         Run(_T("git.exe config user.name"),&UserName,CP_UTF8);\r
 349         return UserName;\r
 350 }\r
 351 CString CGit::GetUserEmail(void)\r
 352 {\r
 353         CString UserName;\r
 354         Run(_T("git.exe config user.email"),&UserName,CP_UTF8);\r
 355         return UserName;\r
 356 }\r
 357 \r
 358 CString CGit::GetCurrentBranch(void)\r
 359 {\r
 360         CString output;\r
 361         //Run(_T("git.exe branch"),&branch);\r
 362 \r
 363         int ret=g_Git.Run(_T("git.exe branch"),&output,CP_UTF8);\r
 364         if(!ret)\r
 365         {               \r
 366                 int pos=0;\r
 367                 CString one;\r
 368                 while( pos>=0 )\r
 369                 {\r
 370                         //i++;\r
 371                         one=output.Tokenize(_T("\n"),pos);\r
 372                         //list.push_back(one.Right(one.GetLength()-2));\r
 373                         if(one[0] == _T('*'))\r
 374                                 return one.Right(one.GetLength()-2);\r
 375                 }\r
 376         }\r
 377         return CString("");\r
 378 }\r
 379 \r
 380 int CGit::BuildOutputFormat(CString &format,bool IsFull)\r
 381 {\r
 382         CString log;\r
 383         log.Format(_T("#<%c>%%x00"),LOG_REV_ITEM_BEGIN);\r
 384         format += log;\r
 385         if(IsFull)\r
 386         {\r
 387                 log.Format(_T("#<%c>%%an%%x00"),LOG_REV_AUTHOR_NAME);\r
 388                 format += log;\r
 389                 log.Format(_T("#<%c>%%ae%%x00"),LOG_REV_AUTHOR_EMAIL);\r
 390                 format += log;\r
 391                 log.Format(_T("#<%c>%%ai%%x00"),LOG_REV_AUTHOR_DATE);\r
 392                 format += log;\r
 393                 log.Format(_T("#<%c>%%cn%%x00"),LOG_REV_COMMIT_NAME);\r
 394                 format += log;\r
 395                 log.Format(_T("#<%c>%%ce%%x00"),LOG_REV_COMMIT_EMAIL);\r
 396                 format += log;\r
 397                 log.Format(_T("#<%c>%%ci%%x00"),LOG_REV_COMMIT_DATE);\r
 398                 format += log;\r
 399                 log.Format(_T("#<%c>%%s%%x00"),LOG_REV_COMMIT_SUBJECT);\r
 400                 format += log;\r
 401                 log.Format(_T("#<%c>%%b%%x00"),LOG_REV_COMMIT_BODY);\r
 402                 format += log;\r
 403         }\r
 404         log.Format(_T("#<%c>%%m%%H%%x00"),LOG_REV_COMMIT_HASH);\r
 405         format += log;\r
 406         log.Format(_T("#<%c>%%P%%x00"),LOG_REV_COMMIT_PARENT);\r
 407         format += log;\r
 408 \r
 409         if(IsFull)\r
 410         {\r
 411                 log.Format(_T("#<%c>%%x00"),LOG_REV_COMMIT_FILE);\r
 412                 format += log;\r
 413         }\r
 414         return 0;\r
 415 }\r
 416 \r
 417 int CGit::GetLog(BYTE_VECTOR& logOut, CString &hash,  CTGitPath *path ,int count,int mask)\r
 418 {\r
 419 \r
 420         CString cmd;\r
 421         CString log;\r
 422         CString num;\r
 423         CString since;\r
 424 \r
 425         CString file;\r
 426 \r
 427         if(path)\r
 428                 file.Format(_T(" -- \"%s\""),path->GetGitPathString());\r
 429         \r
 430         if(count>0)\r
 431                 num.Format(_T("-n%d"),count);\r
 432 \r
 433         CString param;\r
 434 \r
 435         if(mask& LOG_INFO_STAT )\r
 436                 param += _T(" --numstat ");\r
 437         if(mask& LOG_INFO_FILESTATE)\r
 438                 param += _T(" --raw ");\r
 439 \r
 440         if(mask& LOG_INFO_FULLHISTORY)\r
 441                 param += _T(" --full-history ");\r
 442 \r
 443         if(mask& LOG_INFO_BOUNDARY)\r
 444                 param += _T(" --left-right --boundary ");\r
 445 \r
 446         if(mask& CGit::LOG_INFO_ALL_BRANCH)\r
 447                 param += _T(" --all ");\r
 448 \r
 449         if(mask& CGit::LOG_INFO_DETECT_COPYRENAME)\r
 450                 param += _T(" -C ");\r
 451         \r
 452         if(mask& CGit::LOG_INFO_DETECT_RENAME )\r
 453                 param += _T(" -M ");\r
 454 \r
 455         if(mask& CGit::LOG_INFO_FIRST_PARENT )\r
 456                 param += _T(" --first-parent ");\r
 457         \r
 458         if(mask& CGit::LOG_INFO_NO_MERGE )\r
 459                 param += _T(" --no-merges ");\r
 460 \r
 461         if(mask& CGit::LOG_INFO_FOLLOW)\r
 462                 param += _T(" --follow ");\r
 463 \r
 464         param+=hash;\r
 465 \r
 466         cmd.Format(_T("git.exe log %s -z --topo-order %s --parents --pretty=format:\""),\r
 467                                 num,param);\r
 468 \r
 469         BuildOutputFormat(log,!(mask&CGit::LOG_INFO_ONLY_HASH));\r
 470 \r
 471         cmd += log;\r
 472         cmd += CString(_T("\"  "))+hash+file;\r
 473 \r
 474         return Run(cmd,&logOut);\r
 475 }\r
 476 \r
 477 #if 0\r
 478 int CGit::GetShortLog(CString &logOut,CTGitPath * path, int count)\r
 479 {\r
 480         CString cmd;\r
 481         CString log;\r
 482         int n;\r
 483         if(count<0)\r
 484                 n=100;\r
 485         else\r
 486                 n=count;\r
 487         cmd.Format(_T("git.exe log --left-right --boundary --topo-order -n%d --pretty=format:\""),n);\r
 488         BuildOutputFormat(log,false);\r
 489         cmd += log+_T("\"");\r
 490         if (path)\r
 491                 cmd+= _T("  -- \"")+path->GetGitPathString()+_T("\"");\r
 492         //cmd += CString(_T("\" HEAD~40..HEAD"));\r
 493         return Run(cmd,&logOut);\r
 494 }\r
 495 #endif\r
 496 \r
 497 #define BUFSIZE 512\r
 498 void GetTempPath(CString &path)\r
 499 {\r
 500         TCHAR lpPathBuffer[BUFSIZE];\r
 501         DWORD dwRetVal;\r
 502         DWORD dwBufSize=BUFSIZE;\r
 503         dwRetVal = GetTempPath(dwBufSize,     // length of the buffer\r
 504                            lpPathBuffer); // buffer for path \r
 505     if (dwRetVal > dwBufSize || (dwRetVal == 0))\r
 506     {\r
 507         path=_T("");\r
 508     }\r
 509         path.Format(_T("%s"),lpPathBuffer);\r
 510 }\r
 511 CString GetTempFile()\r
 512 {\r
 513         TCHAR lpPathBuffer[BUFSIZE];\r
 514         DWORD dwRetVal;\r
 515     DWORD dwBufSize=BUFSIZE;\r
 516         TCHAR szTempName[BUFSIZE];  \r
 517         UINT uRetVal;\r
 518 \r
 519         dwRetVal = GetTempPath(dwBufSize,     // length of the buffer\r
 520                            lpPathBuffer); // buffer for path \r
 521     if (dwRetVal > dwBufSize || (dwRetVal == 0))\r
 522     {\r
 523         return _T("");\r
 524     }\r
 525          // Create a temporary file. \r
 526     uRetVal = GetTempFileName(lpPathBuffer, // directory for tmp files\r
 527                               TEXT("Patch"),  // temp file name prefix \r
 528                               0,            // create unique name \r
 529                               szTempName);  // buffer for name \r
 530 \r
 531 \r
 532     if (uRetVal == 0)\r
 533     {\r
 534         return _T("");\r
 535     }\r
 536 \r
 537         return CString(szTempName);\r
 538 \r
 539 }\r
 540 \r
 541 int CGit::RunLogFile(CString cmd,CString &filename)\r
 542 {\r
 543         STARTUPINFO si;\r
 544         PROCESS_INFORMATION pi;\r
 545         si.cb=sizeof(STARTUPINFO);\r
 546         GetStartupInfo(&si);\r
 547 \r
 548         SECURITY_ATTRIBUTES   psa={sizeof(psa),NULL,TRUE};;   \r
 549         psa.bInheritHandle=TRUE;   \r
 550     \r
 551         HANDLE   houtfile=CreateFile(filename,GENERIC_WRITE,FILE_SHARE_READ   |   FILE_SHARE_WRITE,   \r
 552                         &psa,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);   \r
 553 \r
 554 \r
 555         si.wShowWindow=SW_HIDE;\r
 556         si.dwFlags=STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;\r
 557         si.hStdOutput   =   houtfile; \r
 558         \r
 559         if(!CreateProcess(NULL,(LPWSTR)cmd.GetString(), NULL,NULL,TRUE,NULL,NULL,(LPWSTR)m_CurrentDir.GetString(),&si,&pi))\r
 560         {\r
 561                 LPVOID lpMsgBuf;\r
 562                 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,\r
 563                         NULL,GetLastError(),MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),\r
 564                         (LPTSTR)&lpMsgBuf,\r
 565                         0,NULL);\r
 566                 return GIT_ERROR_CREATE_PROCESS;\r
 567         }\r
 568         \r
 569         WaitForSingleObject(pi.hProcess,INFINITE);   \r
 570         \r
 571         CloseHandle(pi.hThread);\r
 572         CloseHandle(pi.hProcess);\r
 573         CloseHandle(houtfile);\r
 574         return GIT_SUCCESS;\r
 575 //      return 0;\r
 576 }\r
 577 \r
 578 git_revnum_t CGit::GetHash(CString &friendname)\r
 579 {\r
 580         // NOTE: could replace this with wgGetRevisionID call\r
 581 \r
 582         CString cmd;\r
 583         CString out;\r
 584         cmd.Format(_T("git.exe rev-parse %s" ),friendname);\r
 585         Run(cmd,&out,CP_UTF8);\r
 586         int pos=out.ReverseFind(_T('\n'));\r
 587         if(pos>0)\r
 588                 return out.Left(pos);\r
 589         return out;\r
 590 }\r
 591 \r
 592 int CGit::GetTagList(STRING_VECTOR &list)\r
 593 {\r
 594         int ret;\r
 595         CString cmd,output;\r
 596         cmd=_T("git.exe tag -l");\r
 597         int i=0;\r
 598         ret=g_Git.Run(cmd,&output,CP_UTF8);\r
 599         if(!ret)\r
 600         {               \r
 601                 int pos=0;\r
 602                 CString one;\r
 603                 while( pos>=0 )\r
 604                 {\r
 605                         i++;\r
 606                         one=output.Tokenize(_T("\n"),pos);\r
 607                         list.push_back(one);\r
 608                 }\r
 609         }\r
 610         return ret;\r
 611 }\r
 612 \r
 613 int CGit::GetBranchList(STRING_VECTOR &list,int *current,BRANCH_TYPE type)\r
 614 {\r
 615         int ret;\r
 616         CString cmd,output;\r
 617         cmd=_T("git.exe branch");\r
 618 \r
 619         if(type==(BRANCH_LOCAL|BRANCH_REMOTE))\r
 620                 cmd+=_T(" -a");\r
 621         else if(type==BRANCH_REMOTE)\r
 622                 cmd+=_T(" -r");\r
 623 \r
 624         int i=0;\r
 625         ret=g_Git.Run(cmd,&output,CP_UTF8);\r
 626         if(!ret)\r
 627         {               \r
 628                 int pos=0;\r
 629                 CString one;\r
 630                 while( pos>=0 )\r
 631                 {\r
 632                         one=output.Tokenize(_T("\n"),pos);\r
 633                         list.push_back(one.Right(one.GetLength()-2));\r
 634                         if(one[0] == _T('*'))\r
 635                                 if(current)\r
 636                                         *current=i;\r
 637                         i++;\r
 638                 }\r
 639         }\r
 640         return ret;\r
 641 }\r
 642 \r
 643 int CGit::GetRemoteList(STRING_VECTOR &list)\r
 644 {\r
 645         int ret;\r
 646         CString cmd,output;\r
 647         cmd=_T("git.exe config  --get-regexp remote.*.url");\r
 648         ret=g_Git.Run(cmd,&output,CP_UTF8);\r
 649         if(!ret)\r
 650         {\r
 651                 int pos=0;\r
 652                 CString one;\r
 653                 while( pos>=0 )\r
 654                 {\r
 655                         one=output.Tokenize(_T("\n"),pos);\r
 656                         int start=one.Find(_T("."),0);\r
 657                         if(start>0)\r
 658                         {\r
 659                                 CString url;\r
 660                                 url=one.Right(one.GetLength()-start-1);\r
 661                                 one=url;\r
 662                                 one=one.Left(one.Find(_T("."),0));\r
 663                                 list.push_back(one);\r
 664                         }\r
 665                 }\r
 666         }\r
 667         return ret;\r
 668 }\r
 669 \r
 670 int CGit::GetMapHashToFriendName(MAP_HASH_NAME &map)\r
 671 {\r
 672         int ret;\r
 673         CString cmd,output;\r
 674         cmd=_T("git show-ref -d");\r
 675         ret=g_Git.Run(cmd,&output,CP_UTF8);\r
 676         if(!ret)\r
 677         {\r
 678                 int pos=0;\r
 679                 CString one;\r
 680                 while( pos>=0 )\r
 681                 {\r
 682                         one=output.Tokenize(_T("\n"),pos);\r
 683                         int start=one.Find(_T(" "),0);\r
 684                         if(start>0)\r
 685                         {\r
 686                                 CString name;\r
 687                                 name=one.Right(one.GetLength()-start-1);\r
 688 \r
 689                                 CString hash;\r
 690                                 hash=one.Left(start);\r
 691 \r
 692                                 map[hash].push_back(name);\r
 693                         }\r
 694                 }\r
 695         }\r
 696         return ret;\r
 697 }\r
 698 \r
 699 BOOL CGit::CheckMsysGitDir()\r
 700 {\r
 701         static BOOL bInitialized = FALSE;\r
 702 \r
 703         if (bInitialized)\r
 704         {\r
 705                 return TRUE;\r
 706         }\r
 707 \r
 708         TCHAR *oldpath,*home;\r
 709         size_t size;\r
 710 \r
 711         // set HOME if not set already\r
 712         _tgetenv_s(&size, NULL, 0, _T("HOME"));\r
 713         if (!size)\r
 714         {\r
 715                 _tdupenv_s(&home,&size,_T("USERPROFILE")); \r
 716                 _tputenv_s(_T("HOME"),home);\r
 717                 free(home);\r
 718         }\r
 719 \r
 720         //setup ssh client\r
 721         CRegString sshclient=CRegString(_T("Software\\TortoiseGit\\SSH"));\r
 722         CString ssh=sshclient;\r
 723 \r
 724         if(!ssh.IsEmpty())\r
 725         {\r
 726                 _tputenv_s(_T("GIT_SSH"),ssh);\r
 727         }else\r
 728         {\r
 729                 _tputenv_s(_T("GIT_SSH"),_T(""));\r
 730         }\r
 731 \r
 732         // search PATH if git/bin directory is alredy present\r
 733         if ( FindGitPath() )\r
 734         {\r
 735                 bInitialized = TRUE;\r
 736                 return TRUE;\r
 737         }\r
 738 \r
 739         // add git/bin path to PATH\r
 740 \r
 741         CRegString msysdir=CRegString(REG_MSYSGIT_PATH,_T(""),FALSE,HKEY_LOCAL_MACHINE);\r
 742         CString str=msysdir;\r
 743         if(str.IsEmpty())\r
 744         {\r
 745                 CRegString msysinstalldir=CRegString(REG_MSYSGIT_INSTALL,_T(""),FALSE,HKEY_LOCAL_MACHINE);\r
 746                 str=msysinstalldir;\r
 747                 if ( !str.IsEmpty() )\r
 748                 {\r
 749                         str += (str[str.GetLength()-1] != '\\') ? "\\bin" : "bin";\r
 750                         msysdir=str;\r
 751                         msysdir.write();\r
 752                 }\r
 753                 else\r
 754                 {\r
 755                         return false;\r
 756                 }\r
 757         }\r
 758         //CGit::m_MsysGitPath=str;\r
 759 \r
 760         //set path\r
 761 \r
 762         _tdupenv_s(&oldpath,&size,_T("PATH")); \r
 763 \r
 764         CString path;\r
 765         path.Format(_T("%s;%s"),oldpath,str);\r
 766 \r
 767         _tputenv_s(_T("PATH"),path);\r
 768 \r
 769         free(oldpath);\r
 770 \r
 771 \r
 772     if( !FindGitPath() )\r
 773         {\r
 774                 return false;\r
 775         }\r
 776         else\r
 777         {\r
 778                 bInitialized = TRUE;\r
 779                 return true;\r
 780         }\r
 781 }\r