src/Utils/StringUtils.cpp

   1 // TortoiseSVN - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2003-2011 - TortoiseSVN
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 #include "stdafx.h"
  20 #include "UnicodeUtils.h"
  21 #include "stringutils.h"
  22 #include "ClipboardHelper.h"
  23 #include "SmartHandle.h"
  24
  25 int strwildcmp(const char *wild, const char *string)
  26 {
  27         const char *cp = NULL;
  28         const char *mp = NULL;
  29         while ((*string) && (*wild != '*'))
  30         {
  31                 if ((*wild != *string) && (*wild != '?'))
  32                 {
  33                         return 0;
  34                 }
  35                 wild++;
  36                 string++;
  37         }
  38         while (*string)
  39         {
  40                 if (*wild == '*')
  41                 {
  42                         if (!*++wild)
  43                         {
  44                                 return 1;
  45                         }
  46                         mp = wild;
  47                         cp = string+1;
  48                 }
  49                 else if ((*wild == *string) || (*wild == '?'))
  50                 {
  51                         wild++;
  52                         string++;
  53                 }
  54                 else
  55                 {
  56                         wild = mp;
  57                         string = cp++;
  58                 }
  59         }
  60
  61         while (*wild == '*')
  62         {
  63                 wild++;
  64         }
  65         return !*wild;
  66 }
  67
  68 int wcswildcmp(const wchar_t *wild, const wchar_t *string)
  69 {
  70         const wchar_t *cp = NULL;
  71         const wchar_t *mp = NULL;
  72         while ((*string) && (*wild != '*'))
  73         {
  74                 if ((*wild != *string) && (*wild != '?'))
  75                 {
  76                         return 0;
  77                 }
  78                 wild++;
  79                 string++;
  80         }
  81         while (*string)
  82         {
  83                 if (*wild == '*')
  84                 {
  85                         if (!*++wild)
  86                         {
  87                                 return 1;
  88                         }
  89                         mp = wild;
  90                         cp = string+1;
  91                 }
  92                 else if ((*wild == *string) || (*wild == '?'))
  93                 {
  94                         wild++;
  95                         string++;
  96                 }
  97                 else
  98                 {
  99                         wild = mp;
 100                         string = cp++;
 101                 }
 102         }
 103
 104         while (*wild == '*')
 105         {
 106                 wild++;
 107         }
 108         return !*wild;
 109 }
 110
 111 #ifdef _MFC_VER
 112
 113 void CStringUtils::RemoveAccelerators(CString& text)
 114 {
 115         int pos = 0;
 116         while ((pos=text.Find('&',pos))>=0)
 117         {
 118                 if (text.GetLength() > (pos-1))
 119                 {
 120                         if (text.GetAt(pos+1)!=' ')
 121                                 text.Delete(pos);
 122                 }
 123                 pos++;
 124         }
 125 }
 126
 127 bool CStringUtils::WriteAsciiStringToClipboard(const CStringA& sClipdata, LCID lcid, HWND hOwningWnd)
 128 {
 129         CClipboardHelper clipboardHelper;
 130         if (clipboardHelper.Open(hOwningWnd))
 131         {
 132                 EmptyClipboard();
 133                 HGLOBAL hClipboardData = CClipboardHelper::GlobalAlloc(sClipdata.GetLength()+1);
 134                 if (hClipboardData)
 135                 {
 136                         char* pchData = (char*)GlobalLock(hClipboardData);
 137                         if (pchData)
 138                         {
 139                                 strcpy_s(pchData, sClipdata.GetLength()+1, (LPCSTR)sClipdata);
 140                                 GlobalUnlock(hClipboardData);
 141                                 if (SetClipboardData(CF_TEXT, hClipboardData))
 142                                 {
 143                                         HANDLE hlocmem = CClipboardHelper::GlobalAlloc(sizeof(LCID));
 144                                         if (hlocmem)
 145                                         {
 146                                                 PLCID plcid = (PLCID)GlobalLock(hlocmem);
 147                                                 if (plcid)
 148                                                 {
 149                                                         *plcid = lcid;
 150                                                         SetClipboardData(CF_LOCALE, static_cast<HANDLE>(plcid));
 151                                                 }
 152                                                 GlobalUnlock(hlocmem);
 153                                         }
 154                                         return true;
 155                                 }
 156                         }
 157                 }
 158         }
 159         return false;
 160 }
 161
 162 bool CStringUtils::WriteAsciiStringToClipboard(const CStringW& sClipdata, HWND hOwningWnd)
 163 {
 164         CClipboardHelper clipboardHelper;
 165         if (clipboardHelper.Open(hOwningWnd))
 166         {
 167                 EmptyClipboard();
 168                 HGLOBAL hClipboardData = CClipboardHelper::GlobalAlloc((sClipdata.GetLength()+1)*sizeof(WCHAR));
 169                 if (hClipboardData)
 170                 {
 171                         WCHAR* pchData = (WCHAR*)GlobalLock(hClipboardData);
 172                         if (pchData)
 173                         {
 174                                 _tcscpy_s(pchData, sClipdata.GetLength()+1, (LPCWSTR)sClipdata);
 175                                 GlobalUnlock(hClipboardData);
 176                                 if (SetClipboardData(CF_UNICODETEXT, hClipboardData))
 177                                 {
 178                                         // no need to also set CF_TEXT : the OS does this
 179                                         // automatically.
 180                                         return true;
 181                                 }
 182                         }
 183                 }
 184         }
 185         return false;
 186 }
 187
 188 bool CStringUtils::WriteDiffToClipboard(const CStringA& sClipdata, HWND hOwningWnd)
 189 {
 190         UINT cFormat = RegisterClipboardFormat(_T("TSVN_UNIFIEDDIFF"));
 191         if (cFormat == 0)
 192                 return false;
 193         CClipboardHelper clipboardHelper;
 194         if (clipboardHelper.Open(hOwningWnd))
 195         {
 196                 EmptyClipboard();
 197                 HGLOBAL hClipboardData = CClipboardHelper::GlobalAlloc(sClipdata.GetLength()+1);
 198                 if (hClipboardData)
 199                 {
 200                         char* pchData = (char*)GlobalLock(hClipboardData);
 201                         if (pchData)
 202                         {
 203                                 strcpy_s(pchData, sClipdata.GetLength()+1, (LPCSTR)sClipdata);
 204                                 GlobalUnlock(hClipboardData);
 205                                 if (SetClipboardData(cFormat,hClipboardData)==NULL)
 206                                 {
 207                                         return false;
 208                                 }
 209                                 if (SetClipboardData(CF_TEXT,hClipboardData))
 210                                 {
 211                                         return true;
 212                                 }
 213                         }
 214                 }
 215         }
 216         return false;
 217 }
 218
 219 bool CStringUtils::ReadStringFromTextFile(const CString& path, CString& text)
 220 {
 221         if (!PathFileExists(path))
 222                 return false;
 223         try
 224         {
 225                 CStdioFile file;
 226                 if (!file.Open(path, CFile::modeRead | CFile::shareDenyWrite))
 227                         return false;
 228
 229                 CStringA filecontent;
 230                 UINT filelength = (UINT)file.GetLength();
 231                 int bytesread = (int)file.Read(filecontent.GetBuffer(filelength), filelength);
 232                 filecontent.ReleaseBuffer(bytesread);
 233                 text = CUnicodeUtils::GetUnicode(filecontent);
 234                 file.Close();
 235         }
 236         catch (CFileException* pE)
 237         {
 238                 text.Empty();
 239                 pE->Delete();
 240         }
 241         return true;
 242 }
 243
 244 #endif // #ifdef _MFC_VER
 245
 246 #if defined(CSTRING_AVAILABLE) || defined(_MFC_VER)
 247 BOOL CStringUtils::WildCardMatch(const CString& wildcard, const CString& string)
 248 {
 249         return _tcswildcmp(wildcard, string);
 250 }
 251
 252 CString CStringUtils::LinesWrap(const CString& longstring, int limit /* = 80 */, bool bCompactPaths /* = true */)
 253 {
 254         CString retString;
 255         if ((longstring.GetLength() < limit) || (limit == 0))
 256                 return longstring;  // no wrapping needed.
 257         // now start breaking the string into lines
 258
 259         int linepos = 0;
 260         int lineposold = 0;
 261         CString temp;
 262         while ((linepos = longstring.Find('\n', linepos)) >= 0)
 263         {
 264                 temp = longstring.Mid(lineposold, linepos-lineposold);
 265                 if ((linepos+1)<longstring.GetLength())
 266                         linepos++;
 267                 else
 268                         break;
 269                 lineposold = linepos;
 270                 if (!retString.IsEmpty())
 271                         retString += _T("\n");
 272                 retString += WordWrap(temp, limit, bCompactPaths, false, 4);
 273         }
 274         temp = longstring.Mid(lineposold);
 275         if (!temp.IsEmpty())
 276                 retString += _T("\n");
 277         retString += WordWrap(temp, limit, bCompactPaths, false, 4);
 278         retString.Trim();
 279         return retString;
 280 }
 281
 282 CString CStringUtils::WordWrap(const CString& longstring, int limit, bool bCompactPaths, bool bForceWrap, int tabSize)
 283 {
 284         int nLength = longstring.GetLength();
 285         CString retString;
 286
 287         if (limit < 0)
 288                 limit = 0;
 289
 290         int nLineStart = 0;
 291         int nLineEnd = 0;
 292         int tabOffset = 0;
 293         for (int i = 0; i < nLength; ++i)
 294         {
 295                 if (i-nLineStart+tabOffset >= limit)
 296                 {
 297                         if (nLineEnd == nLineStart)
 298                         {
 299                                 if (bForceWrap)
 300                                         nLineEnd = i;
 301                                 else
 302                                 {
 303                                         while ((i < nLength) && (longstring[i] != ' ') && (longstring[i] != '\t'))
 304                                                 ++i;
 305                                         nLineEnd = i;
 306                                 }
 307                         }
 308                         if (bCompactPaths)
 309                         {
 310                                 CString longline = longstring.Mid(nLineStart, nLineEnd-nLineStart).Left(MAX_PATH-1);
 311                                 if ((bCompactPaths)&&(longline.GetLength() < MAX_PATH))
 312                                 {
 313                                         if (((!PathIsFileSpec(longline))&&longline.Find(':')<3)||(PathIsURL(longline)))
 314                                         {
 315                                                 TCHAR buf[MAX_PATH];
 316                                                 PathCompactPathEx(buf, longline, limit+1, 0);
 317                                                 longline = buf;
 318                                         }
 319                                 }
 320                                 retString += longline;
 321                         }
 322                         else
 323                                 retString += longstring.Mid(nLineStart, nLineEnd-nLineStart);
 324                         retString += L"\n";
 325                         tabOffset = 0;
 326                         nLineStart = nLineEnd;
 327                 }
 328                 if (longstring[i] == ' ')
 329                         nLineEnd = i;
 330                 if (longstring[i] == '\t')
 331                 {
 332                         tabOffset += (tabSize - i % tabSize);
 333                         nLineEnd = i;
 334                 }
 335         }
 336         if (bCompactPaths)
 337         {
 338                 CString longline = longstring.Mid(nLineStart).Left(MAX_PATH-1);
 339                 if ((bCompactPaths)&&(longline.GetLength() < MAX_PATH))
 340                 {
 341                         if (((!PathIsFileSpec(longline))&&longline.Find(':')<3)||(PathIsURL(longline)))
 342                         {
 343                                 TCHAR buf[MAX_PATH];
 344                                 PathCompactPathEx(buf, longline, limit+1, 0);
 345                                 longline = buf;
 346                         }
 347                 }
 348                 retString += longline;
 349         }
 350         else
 351                 retString += longstring.Mid(nLineStart);
 352
 353         return retString;
 354 }
 355 int CStringUtils::GetMatchingLength (const CString& lhs, const CString& rhs)
 356 {
 357         int lhsLength = lhs.GetLength();
 358         int rhsLength = rhs.GetLength();
 359         int maxResult = min (lhsLength, rhsLength);
 360
 361         LPCTSTR pLhs = lhs;
 362         LPCTSTR pRhs = rhs;
 363
 364         for (int i = 0; i < maxResult; ++i)
 365                 if (pLhs[i] != pRhs[i])
 366                         return i;
 367
 368         return maxResult;
 369 }
 370
 371 int CStringUtils::FastCompareNoCase (const CStringW& lhs, const CStringW& rhs)
 372 {
 373         // attempt latin-only comparison
 374
 375         INT_PTR count = min (lhs.GetLength(), rhs.GetLength()+1);
 376         const wchar_t* left = lhs;
 377         const wchar_t* right = rhs;
 378         for (const wchar_t* last = left + count+1; left < last; ++left, ++right)
 379         {
 380                 int leftChar = *left;
 381                 int rightChar = *right;
 382
 383                 int diff = leftChar - rightChar;
 384                 if (diff != 0)
 385                 {
 386                         // case-sensitive comparison found a difference
 387
 388                         if ((leftChar | rightChar) >= 0x80)
 389                         {
 390                                 // non-latin char -> fall back to CRT code
 391                                 // (full comparison required as we might have
 392                                 // skipped special chars / UTF plane selectors)
 393
 394                                 return _wcsicmp (lhs, rhs);
 395                         }
 396
 397                         // normalize to lower case
 398
 399                         if ((leftChar >= 'A') && (leftChar <= 'Z'))
 400                                 leftChar += 'a' - 'A';
 401                         if ((rightChar >= 'A') && (rightChar <= 'Z'))
 402                                 rightChar += 'a' - 'A';
 403
 404                         // compare again
 405
 406                         diff = leftChar - rightChar;
 407                         if (diff != 0)
 408                                 return diff;
 409                 }
 410         }
 411
 412         // must be equal (both ended with a 0)
 413
 414         return 0;
 415 }
 416 #endif // #if defined(CSTRING_AVAILABLE) || defined(_MFC_VER)
 417
 418 bool CStringUtils::WriteStringToTextFile(const std::wstring& path, const std::wstring& text, bool bUTF8 /* = true */)
 419 {
 420         DWORD dwWritten = 0;
 421         CAutoFile hFile = CreateFile(path.c_str(), GENERIC_WRITE, FILE_SHARE_DELETE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 422         if (!hFile)
 423                 return false;
 424
 425         if (bUTF8)
 426         {
 427                 std::string buf = CUnicodeUtils::StdGetUTF8(text);
 428                 if (!WriteFile(hFile, buf.c_str(), (DWORD)buf.length(), &dwWritten, NULL))
 429                 {
 430                         return false;
 431                 }
 432         }
 433         else
 434         {
 435                 if (!WriteFile(hFile, text.c_str(), (DWORD)text.length(), &dwWritten, NULL))
 436                 {
 437                         return false;
 438                 }
 439         }
 440         return true;
 441 }
 442
 443 inline static void PipeToNull(TCHAR* ptr)
 444 {
 445         if (*ptr == '|')
 446                 *ptr = '\0';
 447 }
 448
 449 void CStringUtils::PipesToNulls(TCHAR* buffer, size_t length)
 450 {
 451         TCHAR* ptr = buffer + length;
 452         while (ptr != buffer)
 453         {
 454                 PipeToNull(ptr);
 455                 ptr--;
 456         }
 457 }
 458
 459 void CStringUtils::PipesToNulls(TCHAR* buffer)
 460 {
 461         TCHAR* ptr = buffer;
 462         while (*ptr != 0)
 463         {
 464                 PipeToNull(ptr);
 465                 ptr++;
 466         }
 467 }
 468
 469 #define IsCharNumeric(C) (!IsCharAlpha(C) && IsCharAlphaNumeric(C))
 470
 471
 472 #if defined(_DEBUG) && defined(_MFC_VER)
 473 // Some test cases for these classes
 474 static class StringUtilsTest
 475 {
 476 public:
 477         StringUtilsTest()
 478         {
 479                 CString longline = _T("this is a test of how a string can be splitted into several lines");
 480                 CString splittedline = CStringUtils::WordWrap(longline, 10, true, false, 4);
 481                 ATLTRACE(_T("WordWrap:\n%s\n"), splittedline);
 482                 splittedline = CStringUtils::LinesWrap(longline, 10, true);
 483                 ATLTRACE(_T("LinesWrap:\n%s\n"), splittedline);
 484                 longline = _T("c:\\this_is_a_very_long\\path_on_windows and of course some other words added to make the line longer");
 485                 splittedline = CStringUtils::WordWrap(longline, 10, true, false, 4);
 486                 ATLTRACE(_T("WordWrap:\n%s\n"), splittedline);
 487                 splittedline = CStringUtils::LinesWrap(longline, 10);
 488                 ATLTRACE(_T("LinesWrap:\n%s\n"), splittedline);
 489                 longline = _T("Forced failure in https://myserver.com/a_long_url_to_split PROPFIND error");
 490                 splittedline = CStringUtils::WordWrap(longline, 20, true, false, 4);
 491                 ATLTRACE(_T("WordWrap:\n%s\n"), splittedline);
 492                 splittedline = CStringUtils::LinesWrap(longline, 20, true);
 493                 ATLTRACE(_T("LinesWrap:\n%s\n"), splittedline);
 494                 longline = _T("Forced\nfailure in https://myserver.com/a_long_url_to_split PROPFIND\nerror");
 495                 splittedline = CStringUtils::WordWrap(longline, 40, true, false, 4);
 496                 ATLTRACE(_T("WordWrap:\n%s\n"), splittedline);
 497                 splittedline = CStringUtils::LinesWrap(longline, 40);
 498                 ATLTRACE(_T("LinesWrap:\n%s\n"), splittedline);
 499                 longline = _T("Failed to add file\nc:\\export\\spare\\Devl-JBoss\\development\\head\\src\\something\\CoreApplication\\somethingelse\\src\\com\\yetsomthingelse\\shipper\\DAO\\ShipmentInfoDAO1.java\nc:\\export\\spare\\Devl-JBoss\\development\\head\\src\\something\\CoreApplication\\somethingelse\\src\\com\\yetsomthingelse\\shipper\\DAO\\ShipmentInfoDAO2.java");
 500                 splittedline = CStringUtils::WordWrap(longline, 80, true, false, 4);
 501                 ATLTRACE(_T("WordWrap:\n%s\n"), splittedline);
 502                 splittedline = CStringUtils::LinesWrap(longline);
 503                 ATLTRACE(_T("LinesWrap:\n%s\n"), splittedline);
 504                 longline = _T("The commit comment is not properly formatted.\nFormat:\n  Field 1 : Field 2 : Field 3\nWhere:\nField 1 - Team Name|Triage|Merge|Goal\nField 2 - V1 Backlog Item ID|Triage Number|SVNBranch|Goal Name\nField 3 - Description of change\nExamples:\n\nTeam Gamma : B-12345 : Changed some code\n  Triage : 123 : Fixed production release bug\n  Merge : sprint0812 : Merged sprint0812 into prod\n  Goal : Implement Pre-Commit Hook : Commit message hook impl");
 505                 splittedline = CStringUtils::LinesWrap(longline, 80);
 506                 ATLTRACE(_T("LinesWrap:\n%s\n"), splittedline);
 507         }
 508 } StringUtilsTest;
 509
 510 #endif