src/TortoiseGitBlame/TortoiseGitBlameData.cpp

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