src/Utils/StringUtils.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2011-2019, 2021-2023 - TortoiseGit
   4 // Copyright (C) 2003-2011, 2015 - TortoiseSVN
   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 #include "stdafx.h"
  21 #include "UnicodeUtils.h"
  22 #include "StringUtils.h"
  23 #include "ClipboardHelper.h"
  24 #include "SmartHandle.h"
  25
  26 int strwildcmp(const char *wild, const char *string)
  27 {
  28         const char* cp = nullptr;
  29         const char* mp = nullptr;
  30         while ((*string) && (*wild != '*'))
  31         {
  32                 if ((*wild != *string) && (*wild != '?'))
  33                         return 0;
  34                 ++wild;
  35                 ++string;
  36         }
  37         while (*string)
  38         {
  39                 if (*wild == '*')
  40                 {
  41                         if (!*++wild)
  42                                 return 1;
  43                         mp = wild;
  44                         cp = string+1;
  45                 }
  46                 else if ((*wild == *string) || (*wild == '?'))
  47                 {
  48                         ++wild;
  49                         ++string;
  50                 }
  51                 else
  52                 {
  53                         wild = mp;
  54                         string = cp++;
  55                 }
  56         }
  57
  58         while (*wild == '*')
  59                 ++wild;
  60         return !*wild;
  61 }
  62
  63 int wcswildcmp(const wchar_t *wild, const wchar_t *string)
  64 {
  65         const wchar_t* cp = nullptr;
  66         const wchar_t* mp = nullptr;
  67         while ((*string) && (*wild != '*'))
  68         {
  69                 if ((*wild != *string) && (*wild != '?'))
  70                         return 0;
  71                 ++wild;
  72                 ++string;
  73         }
  74         while (*string)
  75         {
  76                 if (*wild == '*')
  77                 {
  78                         if (!*++wild)
  79                                 return 1;
  80                         mp = wild;
  81                         cp = string+1;
  82                 }
  83                 else if ((*wild == *string) || (*wild == '?'))
  84                 {
  85                         ++wild;
  86                         ++string;
  87                 }
  88                 else
  89                 {
  90                         wild = mp;
  91                         string = cp++;
  92                 }
  93         }
  94
  95         while (*wild == '*')
  96                 ++wild;
  97         return !*wild;
  98 }
  99
 100 #if defined(CSTRING_AVAILABLE) || defined(_MFC_VER)
 101 void CStringUtils::RemoveAccelerators(CString& text)
 102 {
 103         int pos = 0;
 104         while ((pos=text.Find('&',pos))>=0)
 105         {
 106                 if (text.GetLength() > (pos-1))
 107                 {
 108                         if (text.GetAt(pos+1)!=' ')
 109                                 text.Delete(pos);
 110                 }
 111                 ++pos;
 112         }
 113 }
 114
 115 CString CStringUtils::EscapeAccellerators(CString& text)
 116 {
 117         text.Replace(L"&", L"&&");
 118         return text;
 119 }
 120
 121 wchar_t CStringUtils::GetAccellerator(const CString& text)
 122 {
 123         int pos = 0;
 124         while ((pos = text.Find(L'&', pos)) >= 0 && pos + 1 < text.GetLength())
 125         {
 126                 if (text.GetAt(pos + 1) == '&')
 127                         ++pos;
 128                 else if (text.GetAt(pos + 1) != ' ')
 129                         return towupper(text.GetAt(pos + 1));
 130                 ++pos;
 131         }
 132         return L'\0';
 133 }
 134 #endif
 135 #ifdef _MFC_VER
 136 bool CStringUtils::WriteAsciiStringToClipboard(const CStringA& sClipdata, LCID lcid, HWND hOwningWnd)
 137 {
 138         CClipboardHelper clipboardHelper;
 139         if (!clipboardHelper.Open(hOwningWnd))
 140                 return false;
 141
 142         EmptyClipboard();
 143         HGLOBAL hClipboardData = CClipboardHelper::GlobalAlloc(sClipdata.GetLength() + 1);
 144         if (!hClipboardData)
 145                 return false;
 146
 147         auto pchData = static_cast<char*>(GlobalLock(hClipboardData));
 148         if (!pchData)
 149                 return false;
 150
 151         strcpy_s(pchData, sClipdata.GetLength() + 1, static_cast<LPCSTR>(sClipdata));
 152         GlobalUnlock(hClipboardData);
 153         if (!SetClipboardData(CF_TEXT, hClipboardData))
 154                 return false;
 155
 156         HANDLE hlocmem = CClipboardHelper::GlobalAlloc(sizeof(LCID));
 157         if (!hlocmem)
 158                 return false;
 159
 160         auto plcid = static_cast<PLCID>(GlobalLock(hlocmem));
 161         if (plcid)
 162         {
 163                 *plcid = lcid;
 164                 SetClipboardData(CF_LOCALE, static_cast<HANDLE>(plcid));
 165         }
 166         GlobalUnlock(hlocmem);
 167
 168         return true;
 169 }
 170
 171 bool CStringUtils::WriteAsciiStringToClipboard(const CStringW& sClipdata, HWND hOwningWnd)
 172 {
 173         CClipboardHelper clipboardHelper;
 174         if (!clipboardHelper.Open(hOwningWnd))
 175                 return false;
 176
 177         EmptyClipboard();
 178         HGLOBAL hClipboardData = CClipboardHelper::GlobalAlloc((sClipdata.GetLength() + 1) * sizeof(WCHAR));
 179         if (!hClipboardData)
 180                 return false;
 181
 182         auto pchData = static_cast<WCHAR*>(GlobalLock(hClipboardData));
 183         if (!pchData)
 184                 return false;
 185
 186         wcscpy_s(pchData, sClipdata.GetLength() + 1, static_cast<LPCWSTR>(sClipdata));
 187         GlobalUnlock(hClipboardData);
 188         if (!SetClipboardData(CF_UNICODETEXT, hClipboardData))
 189                 return false;
 190
 191         // no need to also set CF_TEXT : the OS does this
 192         // automatically.
 193         return true;
 194 }
 195
 196 bool CStringUtils::WriteDiffToClipboard(const CStringA& sClipdata, HWND hOwningWnd)
 197 {
 198         UINT cFormat = RegisterClipboardFormat(L"TGIT_UNIFIEDDIFF");
 199         if (cFormat == 0)
 200                 return false;
 201         CClipboardHelper clipboardHelper;
 202         if (!clipboardHelper.Open(hOwningWnd))
 203                 return false;
 204
 205         EmptyClipboard();
 206         HGLOBAL hClipboardData = CClipboardHelper::GlobalAlloc(sClipdata.GetLength() + 1);
 207         if (!hClipboardData)
 208                 return false;
 209
 210         auto pchData = static_cast<char*>(GlobalLock(hClipboardData));
 211         if (!pchData)
 212                 return false;
 213
 214         strcpy_s(pchData, sClipdata.GetLength() + 1, static_cast<LPCSTR>(sClipdata));
 215         GlobalUnlock(hClipboardData);
 216         if (!SetClipboardData(cFormat,hClipboardData))
 217                 return false;
 218         if (!SetClipboardData(CF_TEXT, hClipboardData))
 219                 return false;
 220
 221         CString sClipdataW = CUnicodeUtils::GetUnicode(sClipdata);
 222         auto hClipboardDataW = CClipboardHelper::GlobalAlloc((sClipdataW.GetLength() + 1) * sizeof(wchar_t));
 223         if (!hClipboardDataW)
 224                 return false;
 225
 226         auto pchDataW = static_cast<wchar_t*>(GlobalLock(hClipboardDataW));
 227         if (!pchDataW)
 228                 return false;
 229
 230         wcscpy_s(pchDataW, sClipdataW.GetLength() + 1, static_cast<LPCWSTR>(sClipdataW));
 231         GlobalUnlock(hClipboardDataW);
 232         if (!SetClipboardData(CF_UNICODETEXT, hClipboardDataW))
 233                 return false;
 234
 235         return true;
 236 }
 237 #endif
 238
 239 #ifdef _MFC_VER
 240 bool CStringUtils::ReadStringFromTextFile(const CString& path, CString& text)
 241 {
 242         if (!PathFileExists(path))
 243                 return false;
 244         try
 245         {
 246                 CStdioFile file;
 247                 // w/o typeBinary for some files \r gets dropped
 248                 if (!file.Open(path, CFile::typeBinary | CFile::modeRead | CFile::shareDenyWrite) || file.GetLength() >= INT_MAX)
 249                         return false;
 250
 251                 CStringA filecontent;
 252                 const UINT filelength = static_cast<UINT>(file.GetLength());
 253                 const int bytesread = static_cast<int>(file.Read(filecontent.GetBuffer(filelength), filelength));
 254                 filecontent.ReleaseBuffer(bytesread);
 255                 text = CUnicodeUtils::GetUnicode(filecontent);
 256                 file.Close();
 257         }
 258         catch (CFileException* pE)
 259         {
 260                 text.Empty();
 261                 pE->Delete();
 262                 return false;
 263         }
 264         return true;
 265 }
 266 #endif // #ifdef _MFC_VER
 267
 268 #if defined(CSTRING_AVAILABLE) || defined(_MFC_VER)
 269 BOOL CStringUtils::WildCardMatch(const CString& wildcard, const CString& string)
 270 {
 271         return wcswildcmp(wildcard, string);
 272 }
 273
 274 CString CStringUtils::LinesWrap(const CString& longstring, int limit /* = 80 */, bool bCompactPaths /* = true */)
 275 {
 276         CString retString;
 277         if ((longstring.GetLength() < limit) || (limit == 0))
 278                 return longstring;  // no wrapping needed.
 279         // now start breaking the string into lines
 280
 281         int linepos = 0;
 282         int lineposold = 0;
 283         CString temp;
 284         while ((linepos = longstring.Find('\n', linepos)) >= 0)
 285         {
 286                 temp = longstring.Mid(lineposold, linepos-lineposold);
 287                 if ((linepos+1)<longstring.GetLength())
 288                         ++linepos;
 289                 else
 290                         break;
 291                 lineposold = linepos;
 292                 if (!retString.IsEmpty())
 293                         retString += L'\n';
 294                 retString += WordWrap(temp, limit, bCompactPaths, false, 4);
 295         }
 296         temp = longstring.Mid(lineposold);
 297         if (!temp.IsEmpty())
 298                 retString += L'\n';
 299         retString += WordWrap(temp, limit, bCompactPaths, false, 4);
 300         retString.Trim();
 301         return retString;
 302 }
 303
 304 CString CStringUtils::WordWrap(const CString& longstring, int limit, bool bCompactPaths, bool bForceWrap, int tabSize)
 305 {
 306         int nLength = longstring.GetLength();
 307         CString retString;
 308
 309         if (limit < 0)
 310                 limit = 0;
 311
 312         int nLineStart = 0;
 313         int nLineEnd = 0;
 314         int tabOffset = 0;
 315         for (int i = 0; i < nLength; ++i)
 316         {
 317                 if (i-nLineStart+tabOffset >= limit)
 318                 {
 319                         if (nLineEnd == nLineStart)
 320                         {
 321                                 if (bForceWrap)
 322                                         nLineEnd = i;
 323                                 else
 324                                 {
 325                                         while ((i < nLength) && (longstring[i] != ' ') && (longstring[i] != '\t'))
 326                                                 ++i;
 327                                         nLineEnd = i;
 328                                 }
 329                         }
 330                         if (bCompactPaths)
 331                         {
 332                                 CString longline = longstring.Mid(nLineStart, nLineEnd-nLineStart).Left(MAX_PATH-1);
 333                                 if ((bCompactPaths)&&(longline.GetLength() < MAX_PATH))
 334                                 {
 335                                         if (((!PathIsFileSpec(longline))&&longline.Find(':')<3)||(PathIsURL(longline)))
 336                                         {
 337                                                 wchar_t buf[MAX_PATH] = { 0 };
 338                                                 PathCompactPathEx(buf, longline, limit+1, 0);
 339                                                 longline = buf;
 340                                         }
 341                                 }
 342                                 retString += longline;
 343                         }
 344                         else
 345                                 retString += longstring.Mid(nLineStart, nLineEnd-nLineStart);
 346                         retString += L'\n';
 347                         tabOffset = 0;
 348                         nLineStart = nLineEnd;
 349                 }
 350                 if (longstring[i] == ' ')
 351                         nLineEnd = i;
 352                 if (longstring[i] == '\t')
 353                 {
 354                         tabOffset += (tabSize - i % tabSize);
 355                         nLineEnd = i;
 356                 }
 357         }
 358         if (bCompactPaths)
 359         {
 360                 CString longline = longstring.Mid(nLineStart).Left(MAX_PATH-1);
 361                 if ((bCompactPaths)&&(longline.GetLength() < MAX_PATH))
 362                 {
 363                         if (((!PathIsFileSpec(longline))&&longline.Find(':')<3)||(PathIsURL(longline)))
 364                         {
 365                                 wchar_t buf[MAX_PATH] = { 0 };
 366                                 PathCompactPathEx(buf, longline, limit+1, 0);
 367                                 longline = buf;
 368                         }
 369                 }
 370                 retString += longline;
 371         }
 372         else
 373                 retString += longstring.Mid(nLineStart);
 374
 375         return retString;
 376 }
 377
 378 std::vector<CString> CStringUtils::WordWrap(const CString& longstring, int limit, int tabSize)
 379 {
 380         int nLength = longstring.GetLength();
 381         std::vector<CString> retVec;
 382
 383         if (limit < 0)
 384                 limit = 0;
 385
 386         int nLineStart = 0;
 387         int nLineEnd = 0;
 388         int tabOffset = 0;
 389         for (int i = 0; i < nLength; ++i)
 390         {
 391                 if (i - nLineStart + tabOffset >= limit)
 392                 {
 393                         if (nLineEnd == nLineStart)
 394                                 nLineEnd = i;
 395
 396                         auto sMid = longstring.Mid(nLineStart, nLineEnd - nLineStart);
 397                         retVec.push_back(sMid);
 398
 399                         tabOffset = 0;
 400                         nLineStart = nLineEnd;
 401                 }
 402                 if (longstring[i] == ' ')
 403                         nLineEnd = i;
 404                 if (longstring[i] == '\t')
 405                 {
 406                         tabOffset += (tabSize - i % tabSize);
 407                         nLineEnd = i;
 408                 }
 409         }
 410
 411         auto sMid = longstring.Mid(nLineStart);
 412         retVec.push_back(sMid);
 413
 414         return retVec;
 415 }
 416
 417 int CStringUtils::GetMatchingLength (const CString& lhs, const CString& rhs)
 418 {
 419         const int lhsLength = lhs.GetLength();
 420         const int rhsLength = rhs.GetLength();
 421         const int maxResult = min(lhsLength, rhsLength);
 422
 423         LPCWSTR pLhs = lhs;
 424         LPCWSTR pRhs = rhs;
 425
 426         for (int i = 0; i < maxResult; ++i)
 427                 if (pLhs[i] != pRhs[i])
 428                         return i;
 429
 430         return maxResult;
 431 }
 432
 433 int CStringUtils::FastCompareNoCase (const CStringW& lhs, const CStringW& rhs)
 434 {
 435         // attempt latin-only comparison
 436
 437         INT_PTR count = min (lhs.GetLength(), rhs.GetLength()+1);
 438         const wchar_t* left = lhs;
 439         const wchar_t* right = rhs;
 440         for (const wchar_t* last = left + count+1; left < last; ++left, ++right)
 441         {
 442                 int leftChar = *left;
 443                 int rightChar = *right;
 444
 445                 int diff = leftChar - rightChar;
 446                 if (diff != 0)
 447                 {
 448                         // case-sensitive comparison found a difference
 449
 450                         if ((leftChar | rightChar) >= 0x80)
 451                         {
 452                                 // non-latin char -> fall back to CRT code
 453                                 // (full comparison required as we might have
 454                                 // skipped special chars / UTF plane selectors)
 455
 456                                 return _wcsicmp (lhs, rhs);
 457                         }
 458
 459                         // normalize to lower case
 460
 461                         if ((leftChar >= 'A') && (leftChar <= 'Z'))
 462                                 leftChar += 'a' - 'A';
 463                         if ((rightChar >= 'A') && (rightChar <= 'Z'))
 464                                 rightChar += 'a' - 'A';
 465
 466                         // compare again
 467
 468                         diff = leftChar - rightChar;
 469                         if (diff != 0)
 470                                 return diff;
 471                 }
 472         }
 473
 474         // must be equal (both ended with a 0)
 475
 476         return 0;
 477 }
 478
 479 bool CStringUtils::IsPlainReadableASCII(const CString& text)
 480 {
 481         for (int i = 0; i < text.GetLength(); ++i)
 482         {
 483                 if (text[i] < 32 || text[i] >= 127)
 484                         return false;
 485         }
 486         return true;
 487 }
 488
 489 static void cleanup_space(CString& string)
 490 {
 491         for (int pos = 0; pos < string.GetLength(); ++pos)
 492         {
 493                 if (_istspace(string[pos])) {
 494                         string.SetAt(pos, L' ');
 495                         int cnt;
 496                         for (cnt = 0; _istspace(string[pos + cnt + 1]); ++cnt);
 497                         string.Delete(pos + 1, cnt);
 498                 }
 499         }
 500 }
 501
 502 // similar code in CTortoiseGitBlameData::UnquoteFilename
 503 CString CStringUtils::UnescapeGitQuotePath(const CString& s)
 504 {
 505         CStringA t;
 506         const int i_size = s.GetLength();
 507         bool isEscaped = false;
 508         for (int i = 0; i < i_size; ++i)
 509         {
 510                 wchar_t c = s[i];
 511                 if (isEscaped)
 512                 {
 513                         if (c >= '0' && c <= '3')
 514                         {
 515                                 if (i + 2 < i_size)
 516                                 {
 517                                         c = (((c - L'0') & 03) << 6) | (((s[i + 1] - L'0') & 07) << 3) | ((s[i + 2] - L'0') & 07);
 518                                         i += 2;
 519                                         t += c;
 520                                 }
 521                         }
 522                         else
 523                         {
 524                                 // we're on purpose not supporting all possible abbreviations such as \n, \r, \t here as these filenames are invalid on Windows anaway
 525                                 t += c;
 526                         }
 527                         isEscaped = false;
 528                 }
 529                 else
 530                 {
 531                         if (c == L'\\')
 532                                 isEscaped = true;
 533                         else if (c == L'"')
 534                                 break;
 535                         else
 536                                 t += c;
 537                 }
 538         }
 539         return CUnicodeUtils::GetUnicode(t);
 540 }
 541
 542 static void get_sane_name(CString* out, const CString* name, const CString& email)
 543 {
 544         const CString* src = name;
 545         if (name->GetLength() < 3 || 60 < name->GetLength() || wcschr(*name, L'@') || wcschr(*name, L'<') || wcschr(*name, L'>'))
 546                 src = &email;
 547         else if (name == out)
 548                 return;
 549         *out = *src;
 550 }
 551
 552 static void parse_bogus_from(const CString& mailaddress, CString& parsedAddress, CString* parsedName)
 553 {
 554         /* John Doe <johndoe> */
 555
 556         const int bra = mailaddress.Find(L'<');
 557         if (bra < 0)
 558                 return;
 559         const int ket = mailaddress.Find(L'>');
 560         if (ket < 0)
 561                 return;
 562
 563         parsedAddress = mailaddress.Mid(bra + 1, ket - bra - 1);
 564
 565         if (parsedName)
 566         {
 567                 *parsedName = mailaddress.Left(bra).Trim();
 568                 get_sane_name(parsedName, parsedName, parsedAddress);
 569         }
 570 }
 571
 572 void CStringUtils::ParseEmailAddress(CString mailaddress, CString& parsedAddress, CString* parsedName)
 573 {
 574         if (parsedName)
 575                 parsedName->Empty();
 576
 577         mailaddress = mailaddress.Trim();
 578         if (mailaddress.IsEmpty())
 579         {
 580                 parsedAddress.Empty();
 581                 return;
 582         }
 583
 584         if (mailaddress.Left(1) == L'"')
 585         {
 586                 mailaddress = mailaddress.TrimLeft();
 587                 bool escaped = false;
 588                 bool opened = true;
 589                 for (int i = 1; i < mailaddress.GetLength(); ++i)
 590                 {
 591                         if (mailaddress[i] == L'"')
 592                         {
 593                                 if (!escaped)
 594                                 {
 595                                         opened = !opened;
 596                                         if (!opened)
 597                                         {
 598                                                 if (parsedName)
 599                                                         *parsedName = mailaddress.Mid(1, i - 1);
 600                                                 mailaddress = mailaddress.Mid(i);
 601                                                 break;
 602                                         }
 603                                 }
 604                                 else
 605                                 {
 606                                         escaped = false;
 607                                         mailaddress.Delete(i - 1);
 608                                         --i;
 609                                 }
 610                         }
 611                         else if (mailaddress[i] == L'\\')
 612                                 escaped = !escaped;
 613                 }
 614         }
 615
 616         const auto buf = mailaddress.GetBuffer();
 617         auto at = wcschr(buf, L'@');
 618         if (!at)
 619         {
 620                 parse_bogus_from(mailaddress, parsedAddress, parsedName);
 621                 return;
 622         }
 623
 624         /* Pick up the string around '@', possibly delimited with <>
 625          * pair; that is the email part.
 626          */
 627         while (at > buf)
 628         {
 629                 auto c = at[-1];
 630                 if (_istspace(c))
 631                         break;
 632                 if (c == L'<')
 633                 {
 634                         at[-1] = L' ';
 635                         break;
 636                 }
 637                 at--;
 638         }
 639
 640         mailaddress.ReleaseBuffer();
 641         const size_t el = wcscspn(at, L" \n\t\r\v\f>");
 642         parsedAddress = mailaddress.Mid(static_cast<int>(at - buf), static_cast<int>(el));
 643         mailaddress.Delete(static_cast<int>(at - buf), static_cast<int>(el + (at[el] ? 1 : 0)));
 644
 645         /* The remainder is name.  It could be
 646          *
 647          * - "John Doe <john.doe@xz>"                   (a), or
 648          * - "john.doe@xz (John Doe)"                   (b), or
 649          * - "John (zzz) Doe <john.doe@xz> (Comment)"   (c)
 650          *
 651          * but we have removed the email part, so
 652          *
 653          * - remove extra spaces which could stay after email (case 'c'), and
 654          * - trim from both ends, possibly removing the () pair at the end
 655          *   (cases 'b' and 'c').
 656          */
 657         cleanup_space(mailaddress);
 658         mailaddress.Trim();
 659         if (!mailaddress.IsEmpty() && ((mailaddress[0] == L'(' && mailaddress[mailaddress.GetLength() - 1] == L')') || (mailaddress[0] == L'"' && mailaddress[mailaddress.GetLength() - 1] == L'"')))
 660                 mailaddress = mailaddress.Mid(1, mailaddress.GetLength() - 2);
 661
 662         if (parsedName && parsedName->IsEmpty())
 663                 get_sane_name(parsedName, &mailaddress, parsedAddress);
 664 }
 665
 666 bool CStringUtils::StartsWith(const wchar_t* heystack, const CString& needle)
 667 {
 668         return wcsncmp(heystack, needle, needle.GetLength()) == 0;
 669 }
 670
 671 bool CStringUtils::EndsWith(const CString& heystack, const wchar_t* needle)
 672 {
 673         const auto lenNeedle = wcslen(needle);
 674         const auto lenHeystack = static_cast<size_t>(heystack.GetLength());
 675         if (lenNeedle > lenHeystack)
 676                 return false;
 677         return wcsncmp(static_cast<LPCWSTR>(heystack) + (lenHeystack - lenNeedle), needle, lenNeedle) == 0;
 678 }
 679
 680 bool CStringUtils::EndsWith(const CString& heystack, const wchar_t needle)
 681 {
 682         const auto lenHeystack = heystack.GetLength();
 683         if (!lenHeystack)
 684                 return false;
 685         return *(static_cast<LPCWSTR>(heystack) + (lenHeystack - 1)) == needle;
 686 }
 687
 688 bool CStringUtils::EndsWithI(const CString& heystack, const wchar_t* needle)
 689 {
 690         const auto lenNeedle = wcslen(needle);
 691         const auto lenHeystack = static_cast<size_t>(heystack.GetLength());
 692         if (lenNeedle > lenHeystack)
 693                 return false;
 694         return _wcsnicmp(static_cast<LPCWSTR>(heystack) + (lenHeystack - lenNeedle), needle, lenNeedle) == 0;
 695 }
 696
 697 bool CStringUtils::StartsWithI(const wchar_t* heystack, const CString& needle)
 698 {
 699         return _wcsnicmp(heystack, needle, needle.GetLength()) == 0;
 700 }
 701
 702 bool CStringUtils::WriteStringToTextFile(LPCWSTR path, LPCWSTR text, bool bUTF8 /* = true */)
 703 {
 704         return WriteStringToTextFile(static_cast<const std::wstring&>(path), static_cast<const std::wstring&>(text), bUTF8);
 705 }
 706
 707 #endif // #if defined(CSTRING_AVAILABLE) || defined(_MFC_VER)
 708
 709 bool CStringUtils::StartsWith(const wchar_t* heystack, const wchar_t* needle)
 710 {
 711         return wcsncmp(heystack, needle, wcslen(needle)) == 0;
 712 }
 713
 714 bool CStringUtils::StartsWith(const char* heystack, const char* needle)
 715 {
 716         return strncmp(heystack, needle, strlen(needle)) == 0;
 717 }
 718
 719 bool CStringUtils::WriteStringToTextFile(const std::wstring& path, const std::wstring& text, bool bUTF8 /* = true */)
 720 {
 721         DWORD dwWritten = 0;
 722         CAutoFile hFile = CreateFile(path.c_str(), GENERIC_WRITE, FILE_SHARE_DELETE, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
 723         if (!hFile)
 724                 return false;
 725
 726         if (bUTF8)
 727         {
 728                 std::string buf = CUnicodeUtils::StdGetUTF8(text);
 729                 if (!WriteFile(hFile, buf.c_str(), static_cast<DWORD>(buf.length()), &dwWritten, nullptr))
 730                 {
 731                         return false;
 732                 }
 733         }
 734         else
 735         {
 736                 if (!WriteFile(hFile, text.c_str(), static_cast<DWORD>(text.length() * sizeof(wchar_t)), &dwWritten, nullptr))
 737                 {
 738                         return false;
 739                 }
 740         }
 741         return true;
 742 }
 743
 744 inline static void PipeToNull(wchar_t* ptr)
 745 {
 746         if (*ptr == '|')
 747                 *ptr = '\0';
 748 }
 749
 750 void CStringUtils::PipesToNulls(wchar_t* buffer, size_t length)
 751 {
 752         wchar_t* ptr = buffer + length;
 753         while (ptr != buffer)
 754         {
 755                 PipeToNull(ptr);
 756                 ptr--;
 757         }
 758 }
 759
 760 void CStringUtils::PipesToNulls(wchar_t* buffer)
 761 {
 762         wchar_t* ptr = buffer;
 763         while (*ptr)
 764         {
 765                 PipeToNull(ptr);
 766                 ++ptr;
 767         }
 768 }