src/TortoiseGitBlame/TortoiseGitBlameData.cpp

   1 // TortoiseGitBlame - a Viewer for Git Blames
   2
   3 // Copyright (C) 2008-2013 - TortoiseGit
   4 // Copyright (C) 2010-2013 Sven Strickroth <email@cs-ware.de>
   5 // Copyright (C) 2003 Don HO <donho@altern.org>
   6
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License
   9 // as published by the Free Software Foundation; either version 2
  10 // of the License, or (at your option) any later version.
  11
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software Foundation,
  19 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20
  21 // CTortoiseGitBlameData.cpp : implementation of the CTortoiseGitBlameData class
  22 //
  23
  24 #include "stdafx.h"
  25 #include "TortoiseGitBlame.h"
  26 #include "CommonAppUtils.h"
  27 #include "TortoiseGitBlameDoc.h"
  28 #include "TortoiseGitBlameData.h"
  29 #include "MainFrm.h"
  30 #include "EditGotoDlg.h"
  31 #include "LoglistUtils.h"
  32 #include "FileTextLines.h"
  33 #include "UnicodeUtils.h"
  34 #include "MenuEncode.h"
  35 #include "gitdll.h"
  36 #include "SysInfo.h"
  37 #include "StringUtils.h"
  38 #include "TGitPath.h"
  39
  40 wchar_t WideCharSwap2(wchar_t nValue)
  41 {
  42         return (((nValue>> 8)) | (nValue << 8));
  43 }
  44
  45 // CTortoiseGitBlameData construction/destruction
  46
  47 CTortoiseGitBlameData::CTortoiseGitBlameData()
  48 {
  49         m_encode = -1;
  50 }
  51
  52 CTortoiseGitBlameData::~CTortoiseGitBlameData()
  53 {
  54 }
  55
  56 int CTortoiseGitBlameData::GetEncode(unsigned char *buff, int size, int *bomoffset)
  57 {
  58         CFileTextLines textlines;
  59         CFileTextLines::UnicodeType type = textlines.CheckUnicodeType(buff, size);
  60
  61         if (type == CFileTextLines::UTF8BOM)
  62         {
  63                 *bomoffset = 3;
  64                 return CP_UTF8;
  65         }
  66         if (type == CFileTextLines::UTF8)
  67                 return CP_UTF8;
  68
  69         if (type == CFileTextLines::UTF16_LE)
  70                 return 1200;
  71         if (type == CFileTextLines::UTF16_LEBOM)
  72         {
  73                 *bomoffset = 2;
  74                 return 1200;
  75         }
  76
  77         if (type == CFileTextLines::UTF16_BE)
  78                 return 1201;
  79         if (type == CFileTextLines::UTF16_BEBOM)
  80         {
  81                 *bomoffset = 2;
  82                 return 1201;
  83         }
  84
  85         return GetACP();
  86 }
  87
  88 int CTortoiseGitBlameData::GetEncode(int *bomoffset)
  89 {
  90         int encoding = 0;
  91         BYTE_VECTOR rawAll;
  92         for (auto it = m_RawLines.begin(), it_end = m_RawLines.end(); it != it_end; ++it)
  93         {
  94                 rawAll.append(&(*it)[0], it->size());
  95         }
  96         encoding = GetEncode(&rawAll[0], (int)rawAll.size(), bomoffset);
  97         return encoding;
  98 }
  99
 100 void CTortoiseGitBlameData::ParseBlameOutput(BYTE_VECTOR &data, CGitHashMap & HashToRev, DWORD dateFormat, bool bRelativeTimes)
 101 {
 102         std::map<CGitHash, CString> hashToFilename;
 103
 104         std::vector<CGitHash>           hashes;
 105         std::vector<int>                        originalLineNumbers;
 106         std::vector<CString>            filenames;
 107         std::vector<BYTE_VECTOR>        rawLines;
 108         std::vector<CString>            authors;
 109         std::vector<CString>            dates;
 110
 111         CGitHash hash;
 112         int originalLineNumber = 0;
 113         int finalLineNumber = 0;
 114         int numberOfSubsequentLines = 0;
 115         CString filename;
 116
 117         int pos = 0;
 118         bool expectHash = true;
 119         while (pos >= 0 && (size_t)pos < data.size())
 120         {
 121                 if (data[pos] == 0)
 122                         continue;
 123
 124                 int lineBegin = pos;
 125                 int lineEnd = data.findData((const BYTE*)"\n", 1, lineBegin);
 126                 if (lineEnd < 0)
 127                         lineEnd = (int)data.size();
 128
 129                 if (lineEnd > lineBegin)
 130                 {
 131                         if (data[lineBegin] != '\t')
 132                         {
 133                                 if (expectHash)
 134                                 {
 135                                         expectHash = false;
 136                                         if (lineEnd - lineBegin > 40)
 137                                         {
 138                                                 hash.ConvertFromStrA((char*)&data[lineBegin]);
 139
 140                                                 int hashEnd = lineBegin + 40;
 141                                                 int originalLineNumberBegin = hashEnd + 1;
 142                                                 int originalLineNumberEnd = data.findData((const BYTE*)" ", 1, originalLineNumberBegin);
 143                                                 if (originalLineNumberEnd >= 0)
 144                                                 {
 145                                                         originalLineNumber = atoi(CStringA((LPCSTR)&data[originalLineNumberBegin], originalLineNumberEnd - originalLineNumberBegin));
 146                                                         int finalLineNumberBegin = originalLineNumberEnd + 1;
 147                                                         int finalLineNumberEnd = (numberOfSubsequentLines == 0) ? data.findData((const BYTE*)" ", 1, finalLineNumberBegin) : lineEnd;
 148                                                         if (finalLineNumberEnd >= 0)
 149                                                         {
 150                                                                 finalLineNumber = atoi(CStringA((LPCSTR)&data[finalLineNumberBegin], finalLineNumberEnd - finalLineNumberBegin));
 151                                                                 if (numberOfSubsequentLines == 0)
 152                                                                 {
 153                                                                         int numberOfSubsequentLinesBegin = finalLineNumberEnd + 1;
 154                                                                         int numberOfSubsequentLinesEnd = lineEnd;
 155                                                                         numberOfSubsequentLines = atoi(CStringA((LPCSTR)&data[numberOfSubsequentLinesBegin], numberOfSubsequentLinesEnd - numberOfSubsequentLinesBegin));
 156                                                                 }
 157                                                         }
 158                                                         else
 159                                                         {
 160                                                                 // parse error
 161                                                                 finalLineNumber = 0;
 162                                                                 numberOfSubsequentLines = 0;
 163                                                         }
 164                                                 }
 165                                                 else
 166                                                 {
 167                                                         // parse error
 168                                                         finalLineNumber = 0;
 169                                                         numberOfSubsequentLines = 0;
 170                                                 }
 171
 172                                                 auto it = hashToFilename.find(hash);
 173                                                 if (it != hashToFilename.end())
 174                                                         filename = it->second;
 175                                                 else
 176                                                         filename.Empty();
 177                                         }
 178                                         else
 179                                         {
 180                                                 // parse error
 181                                                 finalLineNumber = 0;
 182                                                 numberOfSubsequentLines = 0;
 183                                         }
 184                                 }
 185                                 else
 186                                 {
 187                                         int tokenBegin = lineBegin;
 188                                         int tokenEnd = data.findData((const BYTE*)" ", 1, tokenBegin);
 189                                         if (tokenEnd >= 0)
 190                                         {
 191                                                 if (!strncmp("filename", (const char*)&data[tokenBegin], tokenEnd - tokenBegin))
 192                                                 {
 193                                                         int filenameBegin = tokenEnd + 1;
 194                                                         int filenameEnd = lineEnd;
 195                                                         CStringA filenameA = CStringA((LPCSTR)&data[filenameBegin], filenameEnd - filenameBegin);
 196                                                         filename = UnquoteFilename(filenameA);
 197                                                         auto r = hashToFilename.insert(std::make_pair(hash, filename));
 198                                                         if (!r.second)
 199                                                         {
 200                                                                 r.first->second = filename;
 201                                                         }
 202                                                 }
 203                                         }
 204                                 }
 205                         }
 206                         else
 207                         {
 208                                 expectHash = true;
 209                                 // remove <TAB> at start
 210                                 BYTE_VECTOR line;
 211                                 if (lineEnd - 1 > lineBegin)
 212                                         line.append(&data[lineBegin + 1], lineEnd-lineBegin - 1);
 213
 214                                 hashes.push_back(hash);
 215                                 filenames.push_back(filename);
 216                                 originalLineNumbers.push_back(originalLineNumber);
 217                                 rawLines.push_back(line);
 218                                 --numberOfSubsequentLines;
 219                         }
 220                 }
 221                 pos = lineEnd + 1;
 222         }
 223
 224         for (auto it = hashes.begin(), it_end = hashes.end(); it != it_end; ++it)
 225         {
 226                 CGitHash hash = *it;
 227                 GitRev *pRev;
 228                 try
 229                 {
 230                         pRev = GetRevForHash(HashToRev, hash);
 231                 }
 232                 catch (char* e)
 233                 {
 234                         MessageBox(nullptr, _T("Could not get revision by hash \"") + hash.ToString() + _T("\".\nlibgit reported:\n") + CString(e), _T("TortoiseGit"), MB_OK);
 235                         return;
 236                 }
 237                 if (pRev)
 238                 {
 239                         authors.push_back(pRev->GetAuthorName());
 240                         dates.push_back(CLoglistUtils::FormatDateAndTime(pRev->GetAuthorDate(), dateFormat, true, bRelativeTimes));
 241                 }
 242                 else
 243                 {
 244                         authors.push_back(CString());
 245                         dates.push_back(CString());
 246                 }
 247         }
 248
 249         m_Hash.swap(hashes);
 250         m_OriginalLineNumbers.swap(originalLineNumbers);
 251         m_Filenames.swap(filenames);
 252         m_RawLines.swap(rawLines);
 253
 254         m_Authors.swap(authors);
 255         m_Dates.swap(dates);
 256         // reset detected and applied encoding
 257         m_encode = -1;
 258         m_Utf8Lines.clear();
 259 }
 260
 261 int CTortoiseGitBlameData::UpdateEncoding(int encode)
 262 {
 263         int encoding = encode;
 264         int bomoffset = 0;
 265         if (encoding==0)
 266         {
 267                 BYTE_VECTOR all;
 268                 for (auto it = m_RawLines.begin(); it != m_RawLines.end(); ++it)
 269                 {
 270                         if (!it->empty())
 271                                 all.append(&(*it)[0], it->size());
 272                 }
 273                 encoding = GetEncode(&all[0], (int)all.size(), &bomoffset);
 274         }
 275
 276         if (encoding != m_encode)
 277         {
 278                 m_encode = encoding;
 279
 280                 m_Utf8Lines.resize(m_RawLines.size());
 281                 for (size_t i_Lines = 0; i_Lines < m_RawLines.size(); ++i_Lines)
 282                 {
 283                         const BYTE_VECTOR& rawLine = m_RawLines[i_Lines];
 284
 285                         int bomoffset = 0;
 286                         CStringA lineUtf8;
 287                         lineUtf8.Empty();
 288
 289                         if (!rawLine.empty())
 290                         {
 291                                 if (encoding == 1201)
 292                                 {
 293                                         CString line;
 294                                         int size = (int)((rawLine.size() - bomoffset)/2);
 295                                         TCHAR *buffer = line.GetBuffer(size);
 296                                         memcpy(buffer, &rawLine[bomoffset], sizeof(TCHAR)*size);
 297                                         // swap the bytes to little-endian order to get proper strings in wchar_t format
 298                                         wchar_t * pSwapBuf = buffer;
 299                                         for (int i = 0; i < size; ++i)
 300                                         {
 301                                                 *pSwapBuf = WideCharSwap2(*pSwapBuf);
 302                                                 ++pSwapBuf;
 303                                         }
 304                                         line.ReleaseBuffer();
 305
 306                                         lineUtf8 = CUnicodeUtils::GetUTF8(line);
 307                                 }
 308                                 else if (encoding == 1200)
 309                                 {
 310                                         CString line;
 311                                         // the first bomoffset is 2, after that it's 1 (see issue #920)
 312                                         // also: don't set bomoffset if called from Encodings menu (i.e. start == 42 and bomoffset == 0); bomoffset gets only set if autodetected
 313                                         if (bomoffset == 0 && i_Lines != 0)
 314                                         {
 315                                                 bomoffset = 1;
 316                                         }
 317                                         int size = (int)((rawLine.size() - bomoffset)/2);
 318                                         TCHAR *buffer = line.GetBuffer(size);
 319                                         memcpy(buffer, &rawLine[bomoffset], sizeof(TCHAR) * size);
 320                                         line.ReleaseBuffer();
 321
 322                                         lineUtf8 = CUnicodeUtils::GetUTF8(line);
 323                                 }
 324                                 else if (encoding == CP_UTF8)
 325                                         lineUtf8 = CStringA((LPCSTR)&rawLine[bomoffset], (int)(rawLine.size() - bomoffset));
 326                                 else
 327                                 {
 328                                         CString line = CUnicodeUtils::GetUnicode(CStringA((LPCSTR)&rawLine[bomoffset], (int)(rawLine.size() - bomoffset)), encoding);
 329                                         lineUtf8 = CUnicodeUtils::GetUTF8(line);
 330                                 }
 331                         }
 332
 333                         m_Utf8Lines[i_Lines] = lineUtf8;
 334                         bomoffset = 0;
 335                 }
 336         }
 337         return encoding;
 338 }
 339
 340 int CTortoiseGitBlameData::FindNextLine(CGitHash& CommitHash, int line, bool bUpOrDown)
 341 {
 342         int startline = line;
 343         bool findNoMatch = false;
 344         while (line >= 0 && line < (int)m_Hash.size())
 345         {
 346                 if (m_Hash[line] != CommitHash)
 347                         findNoMatch = true;
 348
 349                 if (m_Hash[line] == CommitHash && findNoMatch)
 350                 {
 351                         if (line == startline + 2)
 352                                 findNoMatch = false;
 353                         else
 354                         {
 355                                 if (bUpOrDown)
 356                                         line = FindFirstLineInBlock(CommitHash, line);
 357                                 return line;
 358                         }
 359                 }
 360                 if (bUpOrDown)
 361                         --line;
 362                 else
 363                         ++line;
 364         }
 365         return -1;
 366 }
 367
 368 static int FindAsciiLower(const CStringA &str, const CStringA &find)
 369 {
 370         if (find.GetLength() == 0)
 371                 return 0;
 372
 373         for (int i = 0; i < str.GetLength(); ++i)
 374         {
 375                 char c = str[i];
 376                 c += (c >= 'A' && c <= 'Z') ? 32 : 0;
 377                 if (c == find[0])
 378                 {
 379                         bool diff = false;
 380                         int k = 1;
 381                         for (int j = i + 1; j < str.GetLength() && k < find.GetLength(); ++j, ++k)
 382                         {
 383                                 char d = str[j];
 384                                 d += (d >= 'A' && d <= 'Z') ? 32 : 0;
 385                                 if (d != find[k])
 386                                 {
 387                                         diff = true;
 388                                         break;
 389                                 }
 390                         }
 391
 392                         if (!diff && k == find.GetLength())
 393                                 return i;
 394                 }
 395         }
 396
 397         return -1;
 398 }
 399
 400 static int FindUtf8Lower(const CStringA& strA, bool allAscii, const CString &findW, const CStringA &findA)
 401 {
 402         if (allAscii)
 403                 return FindAsciiLower(strA, findA);
 404
 405         CString strW = CUnicodeUtils::GetUnicode(strA);
 406         return strW.MakeLower().Find(findW);
 407 }
 408
 409 int CTortoiseGitBlameData::FindFirstLineWrapAround(const CString& what, int line, bool bCaseSensitive)
 410 {
 411         bool allAscii = true;
 412         for (int i = 0; i < what.GetLength(); ++i)
 413         {
 414                 if (what[i] > 0x7f)
 415                 {
 416                         allAscii = false;
 417                         break;
 418                 }
 419         }
 420         CString whatNormalized(what);
 421         if (!bCaseSensitive)
 422         {
 423                 whatNormalized.MakeLower();
 424         }
 425
 426         CStringA whatNormalizedUtf8 = CUnicodeUtils::GetUTF8(whatNormalized);
 427
 428         bool bFound = false;
 429
 430         int i = line;
 431         int numberOfLines = GetNumberOfLines();
 432         if (line < 0 || line + 1 >= numberOfLines)
 433                 i = 0;
 434
 435         do
 436         {
 437                 if (bCaseSensitive)
 438                 {
 439                         if (m_Authors[i].Find(whatNormalized) >= 0)
 440                                 bFound = true;
 441                         else if (m_Utf8Lines[i].Find(whatNormalizedUtf8) >=0)
 442                                 bFound = true;
 443                 }
 444                 else
 445                 {
 446                         if (CString(m_Authors[i]).MakeLower().Find(whatNormalized) >= 0)
 447                                 bFound = true;
 448                         else if (FindUtf8Lower(m_Utf8Lines[i], allAscii, whatNormalized, whatNormalizedUtf8) >= 0)
 449                                 bFound = true;
 450                 }
 451
 452                 if(bFound)
 453                 {
 454                         break;
 455                 }
 456                 else
 457                 {
 458                         ++i;
 459                         if (i >= numberOfLines)
 460                                 i = 0;
 461                 }
 462         } while (i != line);
 463
 464         return bFound ? i : -1;
 465 }
 466
 467 bool CTortoiseGitBlameData::ContainsOnlyFilename(const CString &filename) const
 468 {
 469         for (auto it = m_Filenames.cbegin(); it != m_Filenames.cend(); ++it)
 470         {
 471                 if (filename != *it)
 472                         return false;
 473         }
 474         return true;
 475 }
 476
 477 GitRev* CTortoiseGitBlameData::GetRevForHash(CGitHashMap & HashToRev, CGitHash& hash)
 478 {
 479         auto it = HashToRev.find(hash);
 480         if (it == HashToRev.end())
 481         {
 482                 GitRev rev;
 483                 rev.GetCommitFromHash(hash);
 484                 it = HashToRev.insert(std::make_pair(hash, rev)).first;
 485         }
 486         return &(it->second);
 487 }
 488
 489 CString CTortoiseGitBlameData::UnquoteFilename(CStringA& s)
 490 {
 491         if (s[0] == '"')
 492         {
 493                 CStringA ret;
 494                 int i_size = s.GetLength();
 495                 bool isEscaped = false;
 496                 for (int i = 1; i < i_size; ++i)
 497                 {
 498                         char c = s[i];
 499                         if (isEscaped)
 500                         {
 501                                 if (c >= '0' && c <= '3')
 502                                 {
 503                                         if (i + 2 < i_size)
 504                                         {
 505                                                 c = (((c - '0') & 03) << 6) | (((s[i + 1] - '0') & 07) << 3) | ((s[i + 2] - '0') & 07);
 506                                                 i += 2;
 507                                                 ret += c;
 508                                         }
 509                                 }
 510                                 else
 511                                 {
 512                                         switch (c)
 513                                         {
 514                                         case 'a' : c = '\a'; break;
 515                                         case 'b' : c = '\b'; break;
 516                                         case 't' : c = '\t'; break;
 517                                         case 'n' : c = '\n'; break;
 518                                         case 'v' : c = '\v'; break;
 519                                         case 'f' : c = '\f'; break;
 520                                         case 'r' : c = '\r'; break;
 521                                         }
 522                                         ret += c;
 523                                 }
 524                                 isEscaped = false;
 525                         }
 526                         else
 527                         {
 528                                 if (c == '\\')
 529                                 {
 530                                         isEscaped = true;
 531                                 }
 532                                 else if(c == '"')
 533                                 {
 534                                         break;
 535                                 }
 536                                 else
 537                                 {
 538                                         ret += c;
 539                                 }
 540                         }
 541                 }
 542                 return CUnicodeUtils::GetUnicode(ret);
 543         }
 544         else
 545                 return CUnicodeUtils::GetUnicode(s);
 546 }