git.oblomov.eu Git - wine/blob - dlls/shlwapi/path.c

   1 /*
   2  * Path Functions
   3  *
   4  * Copyright 1999, 2000 Juergen Schmied
   5  * Copyright 2001, 2002 Jon Griffiths
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library 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 GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <stdarg.h>
  26 #include <string.h>
  27 #include <stdlib.h>
  28
  29 #include "wine/unicode.h"
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "wingdi.h"
  33 #include "winuser.h"
  34 #include "winreg.h"
  35 #include "winternl.h"
  36 #define NO_SHLWAPI_STREAM
  37 #include "shlwapi.h"
  38 #include "wine/debug.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  41
  42 /* Get a function pointer from a DLL handle */
  43 #define GET_FUNC(func, module, name, fail) \
  44   do { \
  45     if (!func) { \
  46       if (!SHLWAPI_h##module && !(SHLWAPI_h##module = LoadLibraryA(#module ".dll"))) return fail; \
  47       func = (fn##func)GetProcAddress(SHLWAPI_h##module, name); \
  48       if (!func) return fail; \
  49     } \
  50   } while (0)
  51
  52 /* DLL handles for late bound calls */
  53 static HMODULE SHLWAPI_hshell32;
  54
  55 /* Function pointers for GET_FUNC macro; these need to be global because of gcc bug */
  56 typedef BOOL (WINAPI *fnpIsNetDrive)(int);
  57 static  fnpIsNetDrive pIsNetDrive;
  58
  59 HRESULT WINAPI SHGetWebFolderFilePathW(LPCWSTR,LPWSTR,DWORD);
  60
  61 /*************************************************************************
  62  * PathAppendA    [SHLWAPI.@]
  63  *
  64  * Append one path to another.
  65  *
  66  * PARAMS
  67  *  lpszPath   [I/O] Initial part of path, and destination for output
  68  *  lpszAppend [I]   Path to append
  69  *
  70  * RETURNS
  71  *  Success: TRUE. lpszPath contains the newly created path.
  72  *  Failure: FALSE, if either path is NULL, or PathCombineA() fails.
  73  *
  74  * NOTES
  75  *  lpszAppend must contain at least one backslash ('\') if not NULL.
  76  *  Because PathCombineA() is used to join the paths, the resulting
  77  *  path is also canonicalized.
  78  */
  79 BOOL WINAPI PathAppendA (LPSTR lpszPath, LPCSTR lpszAppend)
  80 {
  81   TRACE("(%s,%s)\n",debugstr_a(lpszPath), debugstr_a(lpszAppend));
  82
  83   if (lpszPath && lpszAppend)
  84   {
  85     if (!PathIsUNCA(lpszAppend))
  86       while (*lpszAppend == '\\')
  87         lpszAppend++;
  88     if (PathCombineA(lpszPath, lpszPath, lpszAppend))
  89       return TRUE;
  90   }
  91   return FALSE;
  92 }
  93
  94 /*************************************************************************
  95  * PathAppendW    [SHLWAPI.@]
  96  *
  97  * See PathAppendA.
  98  */
  99 BOOL WINAPI PathAppendW(LPWSTR lpszPath, LPCWSTR lpszAppend)
 100 {
 101   TRACE("(%s,%s)\n",debugstr_w(lpszPath), debugstr_w(lpszAppend));
 102
 103   if (lpszPath && lpszAppend)
 104   {
 105     if (!PathIsUNCW(lpszAppend))
 106       while (*lpszAppend == '\\')
 107         lpszAppend++;
 108     if (PathCombineW(lpszPath, lpszPath, lpszAppend))
 109       return TRUE;
 110   }
 111   return FALSE;
 112 }
 113
 114 /*************************************************************************
 115  * PathCombineA         [SHLWAPI.@]
 116  *
 117  * Combine two paths together.
 118  *
 119  * PARAMS
 120  *  lpszDest [O] Destination for combined path
 121  *  lpszDir  [I] Directory path
 122  *  lpszFile [I] File path
 123  *
 124  * RETURNS
 125  *  Success: The output path
 126  *  Failure: NULL, if inputs are invalid.
 127  *
 128  * NOTES
 129  *  lpszDest should be at least MAX_PATH in size, and may point to the same
 130  *  memory location as lpszDir. The combined path is canonicalised.
 131  */
 132 LPSTR WINAPI PathCombineA(LPSTR lpszDest, LPCSTR lpszDir, LPCSTR lpszFile)
 133 {
 134   WCHAR szDest[MAX_PATH];
 135   WCHAR szDir[MAX_PATH];
 136   WCHAR szFile[MAX_PATH];
 137   TRACE("(%p,%s,%s)\n", lpszDest, debugstr_a(lpszDir), debugstr_a(lpszFile));
 138
 139   /* Invalid parameters */
 140   if (!lpszDest)
 141     return NULL;
 142   if (!lpszDir && !lpszFile)
 143   {
 144     lpszDest[0] = 0;
 145     return NULL;
 146   }
 147
 148   if (lpszDir)
 149     MultiByteToWideChar(CP_ACP,0,lpszDir,-1,szDir,MAX_PATH);
 150   if (lpszFile)
 151     MultiByteToWideChar(CP_ACP,0,lpszFile,-1,szFile,MAX_PATH);
 152
 153   if (PathCombineW(szDest, lpszDir ? szDir : NULL, lpszFile ? szFile : NULL))
 154     if (WideCharToMultiByte(CP_ACP,0,szDest,-1,lpszDest,MAX_PATH,0,0))
 155       return lpszDest;
 156
 157   lpszDest[0] = 0;
 158   return NULL;
 159 }
 160
 161 /*************************************************************************
 162  * PathCombineW          [SHLWAPI.@]
 163  *
 164  * See PathCombineA.
 165  */
 166 LPWSTR WINAPI PathCombineW(LPWSTR lpszDest, LPCWSTR lpszDir, LPCWSTR lpszFile)
 167 {
 168   WCHAR szTemp[MAX_PATH];
 169   BOOL bUseBoth = FALSE, bStrip = FALSE;
 170
 171   TRACE("(%p,%s,%s)\n", lpszDest, debugstr_w(lpszDir), debugstr_w(lpszFile));
 172
 173   /* Invalid parameters */
 174   if (!lpszDest)
 175     return NULL;
 176   if (!lpszDir && !lpszFile)
 177   {
 178     lpszDest[0] = 0;
 179     return NULL;
 180   }
 181
 182   if ((!lpszFile || !*lpszFile) && lpszDir)
 183   {
 184     /* Use dir only */
 185     lstrcpynW(szTemp, lpszDir, MAX_PATH);
 186   }
 187   else if (!lpszDir || !*lpszDir || !PathIsRelativeW(lpszFile))
 188   {
 189     if (!lpszDir || !*lpszDir || *lpszFile != '\\' || PathIsUNCW(lpszFile))
 190     {
 191       /* Use file only */
 192       lstrcpynW(szTemp, lpszFile, MAX_PATH);
 193     }
 194     else
 195     {
 196       bUseBoth = TRUE;
 197       bStrip = TRUE;
 198     }
 199   }
 200   else
 201     bUseBoth = TRUE;
 202
 203   if (bUseBoth)
 204   {
 205     lstrcpynW(szTemp, lpszDir, MAX_PATH);
 206     if (bStrip)
 207     {
 208       PathStripToRootW(szTemp);
 209       lpszFile++; /* Skip '\' */
 210     }
 211     if (!PathAddBackslashW(szTemp) || strlenW(szTemp) + strlenW(lpszFile) >= MAX_PATH)
 212     {
 213       lpszDest[0] = 0;
 214       return NULL;
 215     }
 216     strcatW(szTemp, lpszFile);
 217   }
 218
 219   PathCanonicalizeW(lpszDest, szTemp);
 220   return lpszDest;
 221 }
 222
 223 /*************************************************************************
 224  * PathAddBackslashA    [SHLWAPI.@]
 225  *
 226  * Append a backslash ('\') to a path if one doesn't exist.
 227  *
 228  * PARAMS
 229  *  lpszPath [I/O] The path to append a backslash to.
 230  *
 231  * RETURNS
 232  *  Success: The position of the last backslash in the path.
 233  *  Failure: NULL, if lpszPath is NULL or the path is too large.
 234  */
 235 LPSTR WINAPI PathAddBackslashA(LPSTR lpszPath)
 236 {
 237   size_t iLen;
 238   LPSTR prev = lpszPath;
 239
 240   TRACE("(%s)\n",debugstr_a(lpszPath));
 241
 242   if (!lpszPath || (iLen = strlen(lpszPath)) >= MAX_PATH)
 243     return NULL;
 244
 245   if (iLen)
 246   {
 247     do {
 248       lpszPath = CharNextA(prev);
 249       if (*lpszPath)
 250         prev = lpszPath;
 251     } while (*lpszPath);
 252     if (*prev != '\\')
 253     {
 254       *lpszPath++ = '\\';
 255       *lpszPath = '\0';
 256     }
 257   }
 258   return lpszPath;
 259 }
 260
 261 /*************************************************************************
 262  * PathAddBackslashW  [SHLWAPI.@]
 263  *
 264  * See PathAddBackslashA.
 265  */
 266 LPWSTR WINAPI PathAddBackslashW( LPWSTR lpszPath )
 267 {
 268   size_t iLen;
 269
 270   TRACE("(%s)\n",debugstr_w(lpszPath));
 271
 272   if (!lpszPath || (iLen = strlenW(lpszPath)) >= MAX_PATH)
 273     return NULL;
 274
 275   if (iLen)
 276   {
 277     lpszPath += iLen;
 278     if (lpszPath[-1] != '\\')
 279     {
 280       *lpszPath++ = '\\';
 281       *lpszPath = '\0';
 282     }
 283   }
 284   return lpszPath;
 285 }
 286
 287 /*************************************************************************
 288  * PathBuildRootA    [SHLWAPI.@]
 289  *
 290  * Create a root drive string (e.g. "A:\") from a drive number.
 291  *
 292  * PARAMS
 293  *  lpszPath [O] Destination for the drive string
 294  *
 295  * RETURNS
 296  *  lpszPath
 297  *
 298  * NOTES
 299  *  If lpszPath is NULL or drive is invalid, nothing is written to lpszPath.
 300  */
 301 LPSTR WINAPI PathBuildRootA(LPSTR lpszPath, int drive)
 302 {
 303   TRACE("(%p,%d)\n", lpszPath, drive);
 304
 305   if (lpszPath && drive >= 0 && drive < 26)
 306   {
 307     lpszPath[0] = 'A' + drive;
 308     lpszPath[1] = ':';
 309     lpszPath[2] = '\\';
 310     lpszPath[3] = '\0';
 311   }
 312   return lpszPath;
 313 }
 314
 315 /*************************************************************************
 316  * PathBuildRootW    [SHLWAPI.@]
 317  *
 318  * See PathBuildRootA.
 319  */
 320 LPWSTR WINAPI PathBuildRootW(LPWSTR lpszPath, int drive)
 321 {
 322   TRACE("(%p,%d)\n", lpszPath, drive);
 323
 324   if (lpszPath && drive >= 0 && drive < 26)
 325   {
 326     lpszPath[0] = 'A' + drive;
 327     lpszPath[1] = ':';
 328     lpszPath[2] = '\\';
 329     lpszPath[3] = '\0';
 330   }
 331   return lpszPath;
 332 }
 333
 334 /*************************************************************************
 335  * PathFindFileNameA  [SHLWAPI.@]
 336  *
 337  * Locate the start of the file name in a path
 338  *
 339  * PARAMS
 340  *  lpszPath [I] Path to search
 341  *
 342  * RETURNS
 343  *  A pointer to the first character of the file name
 344  */
 345 LPSTR WINAPI PathFindFileNameA(LPCSTR lpszPath)
 346 {
 347   LPCSTR lastSlash = lpszPath;
 348
 349   TRACE("(%s)\n",debugstr_a(lpszPath));
 350
 351   while (lpszPath && *lpszPath)
 352   {
 353     if ((*lpszPath == '\\' || *lpszPath == '/' || *lpszPath == ':') &&
 354         lpszPath[1] && lpszPath[1] != '\\' && lpszPath[1] != '/')
 355       lastSlash = lpszPath + 1;
 356     lpszPath = CharNextA(lpszPath);
 357   }
 358   return (LPSTR)lastSlash;
 359 }
 360
 361 /*************************************************************************
 362  * PathFindFileNameW  [SHLWAPI.@]
 363  *
 364  * See PathFindFileNameA.
 365  */
 366 LPWSTR WINAPI PathFindFileNameW(LPCWSTR lpszPath)
 367 {
 368   LPCWSTR lastSlash = lpszPath;
 369
 370   TRACE("(%s)\n",debugstr_w(lpszPath));
 371
 372   while (lpszPath && *lpszPath)
 373   {
 374     if ((*lpszPath == '\\' || *lpszPath == '/' || *lpszPath == ':') &&
 375         lpszPath[1] && lpszPath[1] != '\\' && lpszPath[1] != '/')
 376       lastSlash = lpszPath + 1;
 377     lpszPath++;
 378   }
 379   return (LPWSTR)lastSlash;
 380 }
 381
 382 /*************************************************************************
 383  * PathFindExtensionA  [SHLWAPI.@]
 384  *
 385  * Locate the start of the file extension in a path
 386  *
 387  * PARAMS
 388  *  lpszPath [I] The path to search
 389  *
 390  * RETURNS
 391  *  A pointer to the first character of the extension, the end of
 392  *  the string if the path has no extension, or NULL If lpszPath is NULL
 393  */
 394 LPSTR WINAPI PathFindExtensionA( LPCSTR lpszPath )
 395 {
 396   LPCSTR lastpoint = NULL;
 397
 398   TRACE("(%s)\n", debugstr_a(lpszPath));
 399
 400   if (lpszPath)
 401   {
 402     while (*lpszPath)
 403     {
 404       if (*lpszPath == '\\' || *lpszPath==' ')
 405         lastpoint = NULL;
 406       else if (*lpszPath == '.')
 407         lastpoint = lpszPath;
 408       lpszPath = CharNextA(lpszPath);
 409     }
 410   }
 411   return (LPSTR)(lastpoint ? lastpoint : lpszPath);
 412 }
 413
 414 /*************************************************************************
 415  * PathFindExtensionW  [SHLWAPI.@]
 416  *
 417  * See PathFindExtensionA.
 418  */
 419 LPWSTR WINAPI PathFindExtensionW( LPCWSTR lpszPath )
 420 {
 421   LPCWSTR lastpoint = NULL;
 422
 423   TRACE("(%s)\n", debugstr_w(lpszPath));
 424
 425   if (lpszPath)
 426   {
 427     while (*lpszPath)
 428     {
 429       if (*lpszPath == '\\' || *lpszPath==' ')
 430         lastpoint = NULL;
 431       else if (*lpszPath == '.')
 432         lastpoint = lpszPath;
 433       lpszPath++;
 434     }
 435   }
 436   return (LPWSTR)(lastpoint ? lastpoint : lpszPath);
 437 }
 438
 439 /*************************************************************************
 440  * PathGetArgsA    [SHLWAPI.@]
 441  *
 442  * Find the next argument in a string delimited by spaces.
 443  *
 444  * PARAMS
 445  *  lpszPath [I] The string to search for arguments in
 446  *
 447  * RETURNS
 448  *  The start of the next argument in lpszPath, or NULL if lpszPath is NULL
 449  *
 450  * NOTES
 451  *  Spaces in quoted strings are ignored as delimiters.
 452  */
 453 LPSTR WINAPI PathGetArgsA(LPCSTR lpszPath)
 454 {
 455   BOOL bSeenQuote = FALSE;
 456
 457   TRACE("(%s)\n",debugstr_a(lpszPath));
 458
 459   if (lpszPath)
 460   {
 461     while (*lpszPath)
 462     {
 463       if ((*lpszPath==' ') && !bSeenQuote)
 464         return (LPSTR)lpszPath + 1;
 465       if (*lpszPath == '"')
 466         bSeenQuote = !bSeenQuote;
 467       lpszPath = CharNextA(lpszPath);
 468     }
 469   }
 470   return (LPSTR)lpszPath;
 471 }
 472
 473 /*************************************************************************
 474  * PathGetArgsW    [SHLWAPI.@]
 475  *
 476  * See PathGetArgsA.
 477  */
 478 LPWSTR WINAPI PathGetArgsW(LPCWSTR lpszPath)
 479 {
 480   BOOL bSeenQuote = FALSE;
 481
 482   TRACE("(%s)\n",debugstr_w(lpszPath));
 483
 484   if (lpszPath)
 485   {
 486     while (*lpszPath)
 487     {
 488       if ((*lpszPath==' ') && !bSeenQuote)
 489         return (LPWSTR)lpszPath + 1;
 490       if (*lpszPath == '"')
 491         bSeenQuote = !bSeenQuote;
 492       lpszPath++;
 493     }
 494   }
 495   return (LPWSTR)lpszPath;
 496 }
 497
 498 /*************************************************************************
 499  * PathGetDriveNumberA  [SHLWAPI.@]
 500  *
 501  * Return the drive number from a path
 502  *
 503  * PARAMS
 504  *  lpszPath [I] Path to get the drive number from
 505  *
 506  * RETURNS
 507  *  Success: The drive number corresponding to the drive in the path
 508  *  Failure: -1, if lpszPath contains no valid drive
 509  */
 510 int WINAPI PathGetDriveNumberA(LPCSTR lpszPath)
 511 {
 512   TRACE ("(%s)\n",debugstr_a(lpszPath));
 513
 514   if (lpszPath && !IsDBCSLeadByte(*lpszPath) && lpszPath[1] == ':' &&
 515       tolower(*lpszPath) >= 'a' && tolower(*lpszPath) <= 'z')
 516     return tolower(*lpszPath) - 'a';
 517   return -1;
 518 }
 519
 520 /*************************************************************************
 521  * PathGetDriveNumberW  [SHLWAPI.@]
 522  *
 523  * See PathGetDriveNumberA.
 524  */
 525 int WINAPI PathGetDriveNumberW(LPCWSTR lpszPath)
 526 {
 527   TRACE ("(%s)\n",debugstr_w(lpszPath));
 528
 529   if (lpszPath)
 530   {
 531       WCHAR tl = tolowerW(lpszPath[0]);
 532       if (tl >= 'a' && tl <= 'z' && lpszPath[1] == ':')
 533           return tl - 'a';
 534   }
 535   return -1;
 536 }
 537
 538 /*************************************************************************
 539  * PathRemoveFileSpecA  [SHLWAPI.@]
 540  *
 541  * Remove the file specification from a path.
 542  *
 543  * PARAMS
 544  *  lpszPath [I/O] Path to remove the file spec from
 545  *
 546  * RETURNS
 547  *  TRUE  If the path was valid and modified
 548  *  FALSE Otherwise
 549  */
 550 BOOL WINAPI PathRemoveFileSpecA(LPSTR lpszPath)
 551 {
 552   LPSTR lpszFileSpec = lpszPath;
 553   BOOL bModified = FALSE;
 554
 555   TRACE("(%s)\n",debugstr_a(lpszPath));
 556
 557   if(lpszPath)
 558   {
 559     /* Skip directory or UNC path */
 560     if (*lpszPath == '\\')
 561       lpszFileSpec = ++lpszPath;
 562     if (*lpszPath == '\\')
 563       lpszFileSpec = ++lpszPath;
 564
 565     while (*lpszPath)
 566     {
 567       if(*lpszPath == '\\')
 568         lpszFileSpec = lpszPath; /* Skip dir */
 569       else if(*lpszPath == ':')
 570       {
 571         lpszFileSpec = ++lpszPath; /* Skip drive */
 572         if (*lpszPath == '\\')
 573           lpszFileSpec++;
 574       }
 575       if (!(lpszPath = CharNextA(lpszPath)))
 576         break;
 577     }
 578
 579     if (*lpszFileSpec)
 580     {
 581       *lpszFileSpec = '\0';
 582       bModified = TRUE;
 583     }
 584   }
 585   return bModified;
 586 }
 587
 588 /*************************************************************************
 589  * PathRemoveFileSpecW  [SHLWAPI.@]
 590  *
 591  * See PathRemoveFileSpecA.
 592  */
 593 BOOL WINAPI PathRemoveFileSpecW(LPWSTR lpszPath)
 594 {
 595   LPWSTR lpszFileSpec = lpszPath;
 596   BOOL bModified = FALSE;
 597
 598   TRACE("(%s)\n",debugstr_w(lpszPath));
 599
 600   if(lpszPath)
 601   {
 602     /* Skip directory or UNC path */
 603     if (*lpszPath == '\\')
 604       lpszFileSpec = ++lpszPath;
 605     if (*lpszPath == '\\')
 606       lpszFileSpec = ++lpszPath;
 607
 608     while (*lpszPath)
 609     {
 610       if(*lpszPath == '\\')
 611         lpszFileSpec = lpszPath; /* Skip dir */
 612       else if(*lpszPath == ':')
 613       {
 614         lpszFileSpec = ++lpszPath; /* Skip drive */
 615         if (*lpszPath == '\\')
 616           lpszFileSpec++;
 617       }
 618       lpszPath++;
 619     }
 620
 621     if (*lpszFileSpec)
 622     {
 623       *lpszFileSpec = '\0';
 624       bModified = TRUE;
 625     }
 626   }
 627   return bModified;
 628 }
 629
 630 /*************************************************************************
 631  * PathStripPathA       [SHLWAPI.@]
 632  *
 633  * Remove the initial path from the beginning of a filename
 634  *
 635  * PARAMS
 636  *  lpszPath [I/O] Path to remove the initial path from
 637  *
 638  * RETURNS
 639  *  Nothing.
 640  */
 641 void WINAPI PathStripPathA(LPSTR lpszPath)
 642 {
 643   TRACE("(%s)\n", debugstr_a(lpszPath));
 644
 645   if (lpszPath)
 646   {
 647     LPSTR lpszFileName = PathFindFileNameA(lpszPath);
 648     if(lpszFileName)
 649       RtlMoveMemory(lpszPath, lpszFileName, strlen(lpszFileName)+1);
 650   }
 651 }
 652
 653 /*************************************************************************
 654  * PathStripPathW       [SHLWAPI.@]
 655  *
 656  * See PathStripPathA.
 657  */
 658 void WINAPI PathStripPathW(LPWSTR lpszPath)
 659 {
 660   LPWSTR lpszFileName;
 661
 662   TRACE("(%s)\n", debugstr_w(lpszPath));
 663   lpszFileName = PathFindFileNameW(lpszPath);
 664   if(lpszFileName)
 665     RtlMoveMemory(lpszPath, lpszFileName, (strlenW(lpszFileName)+1)*sizeof(WCHAR));
 666 }
 667
 668 /*************************************************************************
 669  * PathStripToRootA     [SHLWAPI.@]
 670  *
 671  * Reduce a path to its root.
 672  *
 673  * PARAMS
 674  *  lpszPath [I/O] the path to reduce
 675  *
 676  * RETURNS
 677  *  Success: TRUE if the stripped path is a root path
 678  *  Failure: FALSE if the path cannot be stripped or is NULL
 679  */
 680 BOOL WINAPI PathStripToRootA(LPSTR lpszPath)
 681 {
 682   TRACE("(%s)\n", debugstr_a(lpszPath));
 683
 684   if (!lpszPath)
 685     return FALSE;
 686   while(!PathIsRootA(lpszPath))
 687     if (!PathRemoveFileSpecA(lpszPath))
 688       return FALSE;
 689   return TRUE;
 690 }
 691
 692 /*************************************************************************
 693  * PathStripToRootW     [SHLWAPI.@]
 694  *
 695  * See PathStripToRootA.
 696  */
 697 BOOL WINAPI PathStripToRootW(LPWSTR lpszPath)
 698 {
 699   TRACE("(%s)\n", debugstr_w(lpszPath));
 700
 701   if (!lpszPath)
 702     return FALSE;
 703   while(!PathIsRootW(lpszPath))
 704     if (!PathRemoveFileSpecW(lpszPath))
 705       return FALSE;
 706   return TRUE;
 707 }
 708
 709 /*************************************************************************
 710  * PathRemoveArgsA      [SHLWAPI.@]
 711  *
 712  * Strip space separated arguments from a path.
 713  *
 714  * PARAMS
 715  *  lpszPath [I/O] Path to remove arguments from
 716  *
 717  * RETURNS
 718  *  Nothing.
 719  */
 720 void WINAPI PathRemoveArgsA(LPSTR lpszPath)
 721 {
 722   TRACE("(%s)\n",debugstr_a(lpszPath));
 723
 724   if(lpszPath)
 725   {
 726     LPSTR lpszArgs = PathGetArgsA(lpszPath);
 727     if (*lpszArgs)
 728       lpszArgs[-1] = '\0';
 729     else
 730     {
 731       LPSTR lpszLastChar = CharPrevA(lpszPath, lpszArgs);
 732       if(*lpszLastChar == ' ')
 733         *lpszLastChar = '\0';
 734     }
 735   }
 736 }
 737
 738 /*************************************************************************
 739  * PathRemoveArgsW      [SHLWAPI.@]
 740  *
 741  * See PathRemoveArgsA.
 742  */
 743 void WINAPI PathRemoveArgsW(LPWSTR lpszPath)
 744 {
 745   TRACE("(%s)\n",debugstr_w(lpszPath));
 746
 747   if(lpszPath)
 748   {
 749     LPWSTR lpszArgs = PathGetArgsW(lpszPath);
 750     if (*lpszArgs || (lpszArgs > lpszPath && lpszArgs[-1] == ' '))
 751       lpszArgs[-1] = '\0';
 752   }
 753 }
 754
 755 /*************************************************************************
 756  * PathRemoveExtensionA         [SHLWAPI.@]
 757  *
 758  * Remove the file extension from a path
 759  *
 760  * PARAMS
 761  *  lpszPath [I/O] Path to remove the extension from
 762  *
 763  * NOTES
 764  *  The NUL terminator must be written only if extension exists
 765  *  and if the pointed character is not already NUL.
 766  *
 767  * RETURNS
 768  *  Nothing.
 769  */
 770 void WINAPI PathRemoveExtensionA(LPSTR lpszPath)
 771 {
 772   TRACE("(%s)\n", debugstr_a(lpszPath));
 773
 774   if (lpszPath)
 775   {
 776     lpszPath = PathFindExtensionA(lpszPath);
 777     if (lpszPath && *lpszPath != '\0')
 778       *lpszPath = '\0';
 779   }
 780 }
 781
 782 /*************************************************************************
 783  * PathRemoveExtensionW         [SHLWAPI.@]
 784  *
 785  * See PathRemoveExtensionA.
 786 */
 787 void WINAPI PathRemoveExtensionW(LPWSTR lpszPath)
 788 {
 789   TRACE("(%s)\n", debugstr_w(lpszPath));
 790
 791   if (lpszPath)
 792   {
 793     lpszPath = PathFindExtensionW(lpszPath);
 794     if (lpszPath && *lpszPath != '\0')
 795       *lpszPath = '\0';
 796   }
 797 }
 798
 799 /*************************************************************************
 800  * PathRemoveBackslashA [SHLWAPI.@]
 801  *
 802  * Remove a trailing backslash from a path.
 803  *
 804  * PARAMS
 805  *  lpszPath [I/O] Path to remove backslash from
 806  *
 807  * RETURNS
 808  *  Success: A pointer to the end of the path
 809  *  Failure: NULL, if lpszPath is NULL
 810  */
 811 LPSTR WINAPI PathRemoveBackslashA( LPSTR lpszPath )
 812 {
 813   LPSTR szTemp = NULL;
 814
 815   TRACE("(%s)\n", debugstr_a(lpszPath));
 816
 817   if(lpszPath)
 818   {
 819     szTemp = CharPrevA(lpszPath, lpszPath + strlen(lpszPath));
 820     if (!PathIsRootA(lpszPath) && *szTemp == '\\')
 821       *szTemp = '\0';
 822   }
 823   return szTemp;
 824 }
 825
 826 /*************************************************************************
 827  * PathRemoveBackslashW [SHLWAPI.@]
 828  *
 829  * See PathRemoveBackslashA.
 830  */
 831 LPWSTR WINAPI PathRemoveBackslashW( LPWSTR lpszPath )
 832 {
 833   LPWSTR szTemp = NULL;
 834
 835   TRACE("(%s)\n", debugstr_w(lpszPath));
 836
 837   if(lpszPath)
 838   {
 839     szTemp = lpszPath + strlenW(lpszPath);
 840     if (szTemp > lpszPath) szTemp--;
 841     if (!PathIsRootW(lpszPath) && *szTemp == '\\')
 842       *szTemp = '\0';
 843   }
 844   return szTemp;
 845 }
 846
 847 /*************************************************************************
 848  * PathRemoveBlanksA [SHLWAPI.@]
 849  *
 850  * Remove Spaces from the start and end of a path.
 851  *
 852  * PARAMS
 853  *  lpszPath [I/O] Path to strip blanks from
 854  *
 855  * RETURNS
 856  *  Nothing.
 857  */
 858 VOID WINAPI PathRemoveBlanksA(LPSTR lpszPath)
 859 {
 860   TRACE("(%s)\n", debugstr_a(lpszPath));
 861
 862   if(lpszPath && *lpszPath)
 863   {
 864     LPSTR start = lpszPath;
 865
 866     while (*lpszPath == ' ')
 867       lpszPath = CharNextA(lpszPath);
 868
 869     while(*lpszPath)
 870       *start++ = *lpszPath++;
 871
 872     if (start != lpszPath)
 873       while (start[-1] == ' ')
 874         start--;
 875     *start = '\0';
 876   }
 877 }
 878
 879 /*************************************************************************
 880  * PathRemoveBlanksW [SHLWAPI.@]
 881  *
 882  * See PathRemoveBlanksA.
 883  */
 884 VOID WINAPI PathRemoveBlanksW(LPWSTR lpszPath)
 885 {
 886   TRACE("(%s)\n", debugstr_w(lpszPath));
 887
 888   if(lpszPath && *lpszPath)
 889   {
 890     LPWSTR start = lpszPath;
 891
 892     while (*lpszPath == ' ')
 893       lpszPath++;
 894
 895     while(*lpszPath)
 896       *start++ = *lpszPath++;
 897
 898     if (start != lpszPath)
 899       while (start[-1] == ' ')
 900         start--;
 901     *start = '\0';
 902   }
 903 }
 904
 905 /*************************************************************************
 906  * PathQuoteSpacesA [SHLWAPI.@]
 907  *
 908  * Surround a path containing spaces in quotes.
 909  *
 910  * PARAMS
 911  *  lpszPath [I/O] Path to quote
 912  *
 913  * RETURNS
 914  *  Nothing.
 915  *
 916  * NOTES
 917  *  The path is not changed if it is invalid or has no spaces.
 918  */
 919 VOID WINAPI PathQuoteSpacesA(LPSTR lpszPath)
 920 {
 921   TRACE("(%s)\n", debugstr_a(lpszPath));
 922
 923   if(lpszPath && StrChrA(lpszPath,' '))
 924   {
 925     size_t iLen = strlen(lpszPath) + 1;
 926
 927     if (iLen + 2 < MAX_PATH)
 928     {
 929       memmove(lpszPath + 1, lpszPath, iLen);
 930       lpszPath[0] = '"';
 931       lpszPath[iLen] = '"';
 932       lpszPath[iLen + 1] = '\0';
 933     }
 934   }
 935 }
 936
 937 /*************************************************************************
 938  * PathQuoteSpacesW [SHLWAPI.@]
 939  *
 940  * See PathQuoteSpacesA.
 941  */
 942 VOID WINAPI PathQuoteSpacesW(LPWSTR lpszPath)
 943 {
 944   TRACE("(%s)\n", debugstr_w(lpszPath));
 945
 946   if(lpszPath && StrChrW(lpszPath,' '))
 947   {
 948     int iLen = strlenW(lpszPath) + 1;
 949
 950     if (iLen + 2 < MAX_PATH)
 951     {
 952       memmove(lpszPath + 1, lpszPath, iLen * sizeof(WCHAR));
 953       lpszPath[0] = '"';
 954       lpszPath[iLen] = '"';
 955       lpszPath[iLen + 1] = '\0';
 956     }
 957   }
 958 }
 959
 960 /*************************************************************************
 961  * PathUnquoteSpacesA [SHLWAPI.@]
 962  *
 963  * Remove quotes ("") from around a path, if present.
 964  *
 965  * PARAMS
 966  *  lpszPath [I/O] Path to strip quotes from
 967  *
 968  * RETURNS
 969  *  Nothing
 970  *
 971  * NOTES
 972  *  If the path contains a single quote only, an empty string will result.
 973  *  Otherwise quotes are only removed if they appear at the start and end
 974  *  of the path.
 975  */
 976 VOID WINAPI PathUnquoteSpacesA(LPSTR lpszPath)
 977 {
 978   TRACE("(%s)\n", debugstr_a(lpszPath));
 979
 980   if (lpszPath && *lpszPath == '"')
 981   {
 982     DWORD dwLen = strlen(lpszPath) - 1;
 983
 984     if (lpszPath[dwLen] == '"')
 985     {
 986       lpszPath[dwLen] = '\0';
 987       for (; *lpszPath; lpszPath++)
 988         *lpszPath = lpszPath[1];
 989     }
 990   }
 991 }
 992
 993 /*************************************************************************
 994  * PathUnquoteSpacesW [SHLWAPI.@]
 995  *
 996  * See PathUnquoteSpacesA.
 997  */
 998 VOID WINAPI PathUnquoteSpacesW(LPWSTR lpszPath)
 999 {
1000   TRACE("(%s)\n", debugstr_w(lpszPath));
1001
1002   if (lpszPath && *lpszPath == '"')
1003   {
1004     DWORD dwLen = strlenW(lpszPath) - 1;
1005
1006     if (lpszPath[dwLen] == '"')
1007     {
1008       lpszPath[dwLen] = '\0';
1009       for (; *lpszPath; lpszPath++)
1010         *lpszPath = lpszPath[1];
1011     }
1012   }
1013 }
1014
1015 /*************************************************************************
1016  * PathParseIconLocationA  [SHLWAPI.@]
1017  *
1018  * Parse the location of an icon from a path.
1019  *
1020  * PARAMS
1021  *  lpszPath [I/O] The path to parse the icon location from.
1022  *
1023  * RETURNS
1024  *  Success: The number of the icon
1025  *  Failure: 0 if the path does not contain an icon location or is NULL
1026  *
1027  * NOTES
1028  *  The path has surrounding quotes and spaces removed regardless
1029  *  of whether the call succeeds or not.
1030  */
1031 int WINAPI PathParseIconLocationA(LPSTR lpszPath)
1032 {
1033   int iRet = 0;
1034   LPSTR lpszComma;
1035
1036   TRACE("(%s)\n", debugstr_a(lpszPath));
1037
1038   if (lpszPath)
1039   {
1040     if ((lpszComma = strchr(lpszPath, ',')))
1041     {
1042       *lpszComma++ = '\0';
1043       iRet = StrToIntA(lpszComma);
1044     }
1045     PathUnquoteSpacesA(lpszPath);
1046     PathRemoveBlanksA(lpszPath);
1047   }
1048   return iRet;
1049 }
1050
1051 /*************************************************************************
1052  * PathParseIconLocationW  [SHLWAPI.@]
1053  *
1054  * See PathParseIconLocationA.
1055  */
1056 int WINAPI PathParseIconLocationW(LPWSTR lpszPath)
1057 {
1058   int iRet = 0;
1059   LPWSTR lpszComma;
1060
1061   TRACE("(%s)\n", debugstr_w(lpszPath));
1062
1063   if (lpszPath)
1064   {
1065     if ((lpszComma = StrChrW(lpszPath, ',')))
1066     {
1067       *lpszComma++ = '\0';
1068       iRet = StrToIntW(lpszComma);
1069     }
1070     PathUnquoteSpacesW(lpszPath);
1071     PathRemoveBlanksW(lpszPath);
1072   }
1073   return iRet;
1074 }
1075
1076 /*************************************************************************
1077  * @    [SHLWAPI.4]
1078  *
1079  * Unicode version of PathFileExistsDefExtA.
1080  */
1081 BOOL WINAPI PathFileExistsDefExtW(LPWSTR lpszPath,DWORD dwWhich)
1082 {
1083   static const WCHAR pszExts[][5]  = { { '.', 'p', 'i', 'f', 0},
1084                                        { '.', 'c', 'o', 'm', 0},
1085                                        { '.', 'e', 'x', 'e', 0},
1086                                        { '.', 'b', 'a', 't', 0},
1087                                        { '.', 'l', 'n', 'k', 0},
1088                                        { '.', 'c', 'm', 'd', 0},
1089                                        { 0, 0, 0, 0, 0} };
1090
1091   TRACE("(%s,%d)\n", debugstr_w(lpszPath), dwWhich);
1092
1093   if (!lpszPath || PathIsUNCServerW(lpszPath) || PathIsUNCServerShareW(lpszPath))
1094     return FALSE;
1095
1096   if (dwWhich)
1097   {
1098     LPCWSTR szExt = PathFindExtensionW(lpszPath);
1099     if (!*szExt || dwWhich & 0x40)
1100     {
1101       size_t iChoose = 0;
1102       int iLen = lstrlenW(lpszPath);
1103       if (iLen > (MAX_PATH - 5))
1104         return FALSE;
1105       while ( (dwWhich & 0x1) && pszExts[iChoose][0] )
1106       {
1107         lstrcpyW(lpszPath + iLen, pszExts[iChoose]);
1108         if (PathFileExistsW(lpszPath))
1109           return TRUE;
1110         iChoose++;
1111         dwWhich >>= 1;
1112       }
1113       *(lpszPath + iLen) = (WCHAR)'\0';
1114       return FALSE;
1115     }
1116   }
1117   return PathFileExistsW(lpszPath);
1118 }
1119
1120 /*************************************************************************
1121  * @    [SHLWAPI.3]
1122  *
1123  * Determine if a file exists locally and is of an executable type.
1124  *
1125  * PARAMS
1126  *  lpszPath       [I/O] File to search for
1127  *  dwWhich        [I]   Type of executable to search for
1128  *
1129  * RETURNS
1130  *  TRUE  If the file was found. lpszPath contains the file name.
1131  *  FALSE Otherwise.
1132  *
1133  * NOTES
1134  *  lpszPath is modified in place and must be at least MAX_PATH in length.
1135  *  If the function returns FALSE, the path is modified to its original state.
1136  *  If the given path contains an extension or dwWhich is 0, executable
1137  *  extensions are not checked.
1138  *
1139  *  Ordinals 3-6 are a classic case of MS exposing limited functionality to
1140  *  users (here through PathFindOnPathA()) and keeping advanced functionality for
1141  *  their own developers exclusive use. Monopoly, anyone?
1142  */
1143 BOOL WINAPI PathFileExistsDefExtA(LPSTR lpszPath,DWORD dwWhich)
1144 {
1145   BOOL bRet = FALSE;
1146
1147   TRACE("(%s,%d)\n", debugstr_a(lpszPath), dwWhich);
1148
1149   if (lpszPath)
1150   {
1151     WCHAR szPath[MAX_PATH];
1152     MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
1153     bRet = PathFileExistsDefExtW(szPath, dwWhich);
1154     if (bRet)
1155       WideCharToMultiByte(CP_ACP,0,szPath,-1,lpszPath,MAX_PATH,0,0);
1156   }
1157   return bRet;
1158 }
1159
1160 /*************************************************************************
1161  * SHLWAPI_PathFindInOtherDirs
1162  *
1163  * Internal helper for SHLWAPI_PathFindOnPathExA/W.
1164  */
1165 static BOOL SHLWAPI_PathFindInOtherDirs(LPWSTR lpszFile, DWORD dwWhich)
1166 {
1167   static const WCHAR szSystem[] = { 'S','y','s','t','e','m','\0'};
1168   static const WCHAR szPath[] = { 'P','A','T','H','\0'};
1169   DWORD dwLenPATH;
1170   LPCWSTR lpszCurr;
1171   WCHAR *lpszPATH;
1172   WCHAR buff[MAX_PATH];
1173
1174   TRACE("(%s,%08x)\n", debugstr_w(lpszFile), dwWhich);
1175
1176   /* Try system directories */
1177   GetSystemDirectoryW(buff, MAX_PATH);
1178   if (!PathAppendW(buff, lpszFile))
1179      return FALSE;
1180   if (PathFileExistsDefExtW(buff, dwWhich))
1181   {
1182     strcpyW(lpszFile, buff);
1183     return TRUE;
1184   }
1185   GetWindowsDirectoryW(buff, MAX_PATH);
1186   if (!PathAppendW(buff, szSystem ) || !PathAppendW(buff, lpszFile))
1187     return FALSE;
1188   if (PathFileExistsDefExtW(buff, dwWhich))
1189   {
1190     strcpyW(lpszFile, buff);
1191     return TRUE;
1192   }
1193   GetWindowsDirectoryW(buff, MAX_PATH);
1194   if (!PathAppendW(buff, lpszFile))
1195     return FALSE;
1196   if (PathFileExistsDefExtW(buff, dwWhich))
1197   {
1198     strcpyW(lpszFile, buff);
1199     return TRUE;
1200   }
1201   /* Try dirs listed in %PATH% */
1202   dwLenPATH = GetEnvironmentVariableW(szPath, buff, MAX_PATH);
1203
1204   if (!dwLenPATH || !(lpszPATH = HeapAlloc(GetProcessHeap(), 0, (dwLenPATH + 1) * sizeof (WCHAR))))
1205     return FALSE;
1206
1207   GetEnvironmentVariableW(szPath, lpszPATH, dwLenPATH + 1);
1208   lpszCurr = lpszPATH;
1209   while (lpszCurr)
1210   {
1211     LPCWSTR lpszEnd = lpszCurr;
1212     LPWSTR pBuff = buff;
1213
1214     while (*lpszEnd == ' ')
1215       lpszEnd++;
1216     while (*lpszEnd && *lpszEnd != ';')
1217       *pBuff++ = *lpszEnd++;
1218     *pBuff = '\0';
1219
1220     if (*lpszEnd)
1221       lpszCurr = lpszEnd + 1;
1222     else
1223       lpszCurr = NULL; /* Last Path, terminate after this */
1224
1225     if (!PathAppendW(buff, lpszFile))
1226     {
1227       HeapFree(GetProcessHeap(), 0, lpszPATH);
1228       return FALSE;
1229     }
1230     if (PathFileExistsDefExtW(buff, dwWhich))
1231     {
1232       strcpyW(lpszFile, buff);
1233       HeapFree(GetProcessHeap(), 0, lpszPATH);
1234       return TRUE;
1235     }
1236   }
1237   HeapFree(GetProcessHeap(), 0, lpszPATH);
1238   return FALSE;
1239 }
1240
1241 /*************************************************************************
1242  * @    [SHLWAPI.5]
1243  *
1244  * Search a range of paths for a specific type of executable.
1245  *
1246  * PARAMS
1247  *  lpszFile       [I/O] File to search for
1248  *  lppszOtherDirs [I]   Other directories to look in
1249  *  dwWhich        [I]   Type of executable to search for
1250  *
1251  * RETURNS
1252  *  Success: TRUE. The path to the executable is stored in lpszFile.
1253  *  Failure: FALSE. The path to the executable is unchanged.
1254  */
1255 BOOL WINAPI PathFindOnPathExA(LPSTR lpszFile,LPCSTR *lppszOtherDirs,DWORD dwWhich)
1256 {
1257   WCHAR szFile[MAX_PATH];
1258   WCHAR buff[MAX_PATH];
1259
1260   TRACE("(%s,%p,%08x)\n", debugstr_a(lpszFile), lppszOtherDirs, dwWhich);
1261
1262   if (!lpszFile || !PathIsFileSpecA(lpszFile))
1263     return FALSE;
1264
1265   MultiByteToWideChar(CP_ACP,0,lpszFile,-1,szFile,MAX_PATH);
1266
1267   /* Search provided directories first */
1268   if (lppszOtherDirs && *lppszOtherDirs)
1269   {
1270     WCHAR szOther[MAX_PATH];
1271     LPCSTR *lpszOtherPath = lppszOtherDirs;
1272
1273     while (lpszOtherPath && *lpszOtherPath && (*lpszOtherPath)[0])
1274     {
1275       MultiByteToWideChar(CP_ACP,0,*lpszOtherPath,-1,szOther,MAX_PATH);
1276       PathCombineW(buff, szOther, szFile);
1277       if (PathFileExistsDefExtW(buff, dwWhich))
1278       {
1279         WideCharToMultiByte(CP_ACP,0,buff,-1,lpszFile,MAX_PATH,0,0);
1280         return TRUE;
1281       }
1282       lpszOtherPath++;
1283     }
1284   }
1285   /* Not found, try system and path dirs */
1286   if (SHLWAPI_PathFindInOtherDirs(szFile, dwWhich))
1287   {
1288     WideCharToMultiByte(CP_ACP,0,szFile,-1,lpszFile,MAX_PATH,0,0);
1289     return TRUE;
1290   }
1291   return FALSE;
1292 }
1293
1294 /*************************************************************************
1295  * @    [SHLWAPI.6]
1296  *
1297  * Unicode version of PathFindOnPathExA.
1298  */
1299 BOOL WINAPI PathFindOnPathExW(LPWSTR lpszFile,LPCWSTR *lppszOtherDirs,DWORD dwWhich)
1300 {
1301   WCHAR buff[MAX_PATH];
1302
1303   TRACE("(%s,%p,%08x)\n", debugstr_w(lpszFile), lppszOtherDirs, dwWhich);
1304
1305   if (!lpszFile || !PathIsFileSpecW(lpszFile))
1306     return FALSE;
1307
1308   /* Search provided directories first */
1309   if (lppszOtherDirs && *lppszOtherDirs)
1310   {
1311     LPCWSTR *lpszOtherPath = lppszOtherDirs;
1312     while (lpszOtherPath && *lpszOtherPath && (*lpszOtherPath)[0])
1313     {
1314       PathCombineW(buff, *lpszOtherPath, lpszFile);
1315       if (PathFileExistsDefExtW(buff, dwWhich))
1316       {
1317         strcpyW(lpszFile, buff);
1318         return TRUE;
1319       }
1320       lpszOtherPath++;
1321     }
1322   }
1323   /* Not found, try system and path dirs */
1324   return SHLWAPI_PathFindInOtherDirs(lpszFile, dwWhich);
1325 }
1326
1327 /*************************************************************************
1328  * PathFindOnPathA      [SHLWAPI.@]
1329  *
1330  * Search a range of paths for an executable.
1331  *
1332  * PARAMS
1333  *  lpszFile       [I/O] File to search for
1334  *  lppszOtherDirs [I]   Other directories to look in
1335  *
1336  * RETURNS
1337  *  Success: TRUE. The path to the executable is stored in lpszFile.
1338  *  Failure: FALSE. The path to the executable is unchanged.
1339  */
1340 BOOL WINAPI PathFindOnPathA(LPSTR lpszFile, LPCSTR *lppszOtherDirs)
1341 {
1342   TRACE("(%s,%p)\n", debugstr_a(lpszFile), lppszOtherDirs);
1343   return PathFindOnPathExA(lpszFile, lppszOtherDirs, 0);
1344  }
1345
1346 /*************************************************************************
1347  * PathFindOnPathW      [SHLWAPI.@]
1348  *
1349  * See PathFindOnPathA.
1350  */
1351 BOOL WINAPI PathFindOnPathW(LPWSTR lpszFile, LPCWSTR *lppszOtherDirs)
1352 {
1353   TRACE("(%s,%p)\n", debugstr_w(lpszFile), lppszOtherDirs);
1354   return PathFindOnPathExW(lpszFile,lppszOtherDirs, 0);
1355 }
1356
1357 /*************************************************************************
1358  * PathCompactPathExA   [SHLWAPI.@]
1359  *
1360  * Compact a path into a given number of characters.
1361  *
1362  * PARAMS
1363  *  lpszDest [O] Destination for compacted path
1364  *  lpszPath [I] Source path
1365  *  cchMax   [I] Maximum size of compacted path
1366  *  dwFlags  [I] Reserved
1367  *
1368  * RETURNS
1369  *  Success: TRUE. The compacted path is written to lpszDest.
1370  *  Failure: FALSE. lpszPath is undefined.
1371  *
1372  * NOTES
1373  *  If cchMax is given as 0, lpszDest will still be NUL terminated.
1374  *
1375  *  The Win32 version of this function contains a bug: When cchMax == 7,
1376  *  8 bytes will be written to lpszDest. This bug is fixed in the Wine
1377  *  implementation.
1378  *
1379  *  Some relative paths will be different when cchMax == 5 or 6. This occurs
1380  *  because Win32 will insert a "\" in lpszDest, even if one is
1381  *  not present in the original path.
1382  */
1383 BOOL WINAPI PathCompactPathExA(LPSTR lpszDest, LPCSTR lpszPath,
1384                                UINT cchMax, DWORD dwFlags)
1385 {
1386   BOOL bRet = FALSE;
1387
1388   TRACE("(%p,%s,%d,0x%08x)\n", lpszDest, debugstr_a(lpszPath), cchMax, dwFlags);
1389
1390   if (lpszPath && lpszDest)
1391   {
1392     WCHAR szPath[MAX_PATH];
1393     WCHAR szDest[MAX_PATH];
1394
1395     MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
1396     szDest[0] = '\0';
1397     bRet = PathCompactPathExW(szDest, szPath, cchMax, dwFlags);
1398     WideCharToMultiByte(CP_ACP,0,szDest,-1,lpszDest,MAX_PATH,0,0);
1399   }
1400   return bRet;
1401 }
1402
1403 /*************************************************************************
1404  * PathCompactPathExW   [SHLWAPI.@]
1405  *
1406  * See PathCompactPathExA.
1407  */
1408 BOOL WINAPI PathCompactPathExW(LPWSTR lpszDest, LPCWSTR lpszPath,
1409                                UINT cchMax, DWORD dwFlags)
1410 {
1411   static const WCHAR szEllipses[] = { '.', '.', '.', '\0' };
1412   LPCWSTR lpszFile;
1413   DWORD dwLen, dwFileLen = 0;
1414
1415   TRACE("(%p,%s,%d,0x%08x)\n", lpszDest, debugstr_w(lpszPath), cchMax, dwFlags);
1416
1417   if (!lpszPath)
1418     return FALSE;
1419
1420   if (!lpszDest)
1421   {
1422     WARN("Invalid lpszDest would crash under Win32!\n");
1423     return FALSE;
1424   }
1425
1426   *lpszDest = '\0';
1427
1428   if (cchMax < 2)
1429     return TRUE;
1430
1431   dwLen = strlenW(lpszPath) + 1;
1432
1433   if (dwLen < cchMax)
1434   {
1435     /* Don't need to compact */
1436     memcpy(lpszDest, lpszPath, dwLen * sizeof(WCHAR));
1437     return TRUE;
1438   }
1439
1440   /* Path must be compacted to fit into lpszDest */
1441   lpszFile = PathFindFileNameW(lpszPath);
1442   dwFileLen = lpszPath + dwLen - lpszFile;
1443
1444   if (dwFileLen == dwLen)
1445   {
1446     /* No root in psth */
1447     if (cchMax <= 4)
1448     {
1449       while (--cchMax > 0) /* No room left for anything but ellipses */
1450         *lpszDest++ = '.';
1451       *lpszDest = '\0';
1452       return TRUE;
1453     }
1454     /* Compact the file name with ellipses at the end */
1455     cchMax -= 4;
1456     memcpy(lpszDest, lpszFile, cchMax * sizeof(WCHAR));
1457     strcpyW(lpszDest + cchMax, szEllipses);
1458     return TRUE;
1459   }
1460   /* We have a root in the path */
1461   lpszFile--; /* Start compacted filename with the path separator */
1462   dwFileLen++;
1463
1464   if (dwFileLen + 3 > cchMax)
1465   {
1466     /* Compact the file name */
1467     if (cchMax <= 4)
1468     {
1469       while (--cchMax > 0) /* No room left for anything but ellipses */
1470         *lpszDest++ = '.';
1471       *lpszDest = '\0';
1472       return TRUE;
1473     }
1474     strcpyW(lpszDest, szEllipses);
1475     lpszDest += 3;
1476     cchMax -= 4;
1477     *lpszDest++ = *lpszFile++;
1478     if (cchMax <= 4)
1479     {
1480       while (--cchMax > 0) /* No room left for anything but ellipses */
1481         *lpszDest++ = '.';
1482       *lpszDest = '\0';
1483       return TRUE;
1484     }
1485     cchMax -= 4;
1486     memcpy(lpszDest, lpszFile, cchMax * sizeof(WCHAR));
1487     strcpyW(lpszDest + cchMax, szEllipses);
1488     return TRUE;
1489   }
1490
1491   /* Only the root needs to be Compacted */
1492   dwLen = cchMax - dwFileLen - 3;
1493   memcpy(lpszDest, lpszPath, dwLen * sizeof(WCHAR));
1494   strcpyW(lpszDest + dwLen, szEllipses);
1495   strcpyW(lpszDest + dwLen + 3, lpszFile);
1496   return TRUE;
1497 }
1498
1499 /*************************************************************************
1500  * PathIsRelativeA      [SHLWAPI.@]
1501  *
1502  * Determine if a path is a relative path.
1503  *
1504  * PARAMS
1505  *  lpszPath [I] Path to check
1506  *
1507  * RETURNS
1508  *  TRUE:  The path is relative, or is invalid.
1509  *  FALSE: The path is not relative.
1510  */
1511 BOOL WINAPI PathIsRelativeA (LPCSTR lpszPath)
1512 {
1513   TRACE("(%s)\n",debugstr_a(lpszPath));
1514
1515   if (!lpszPath || !*lpszPath || IsDBCSLeadByte(*lpszPath))
1516     return TRUE;
1517   if (*lpszPath == '\\' || (*lpszPath && lpszPath[1] == ':'))
1518     return FALSE;
1519   return TRUE;
1520 }
1521
1522 /*************************************************************************
1523  *  PathIsRelativeW     [SHLWAPI.@]
1524  *
1525  * See PathIsRelativeA.
1526  */
1527 BOOL WINAPI PathIsRelativeW (LPCWSTR lpszPath)
1528 {
1529   TRACE("(%s)\n",debugstr_w(lpszPath));
1530
1531   if (!lpszPath || !*lpszPath)
1532     return TRUE;
1533   if (*lpszPath == '\\' || (*lpszPath && lpszPath[1] == ':'))
1534     return FALSE;
1535   return TRUE;
1536 }
1537
1538 /*************************************************************************
1539  * PathIsRootA          [SHLWAPI.@]
1540  *
1541  * Determine if a path is a root path.
1542  *
1543  * PARAMS
1544  *  lpszPath [I] Path to check
1545  *
1546  * RETURNS
1547  *  TRUE  If lpszPath is valid and a root path,
1548  *  FALSE Otherwise
1549  */
1550 BOOL WINAPI PathIsRootA(LPCSTR lpszPath)
1551 {
1552   TRACE("(%s)\n", debugstr_a(lpszPath));
1553
1554   if (lpszPath && *lpszPath)
1555   {
1556     if (*lpszPath == '\\')
1557     {
1558       if (!lpszPath[1])
1559         return TRUE; /* \ */
1560       else if (lpszPath[1]=='\\')
1561       {
1562         BOOL bSeenSlash = FALSE;
1563         lpszPath += 2;
1564
1565         /* Check for UNC root path */
1566         while (*lpszPath)
1567         {
1568           if (*lpszPath == '\\')
1569           {
1570             if (bSeenSlash)
1571               return FALSE;
1572             bSeenSlash = TRUE;
1573           }
1574           lpszPath = CharNextA(lpszPath);
1575         }
1576         return TRUE;
1577       }
1578     }
1579     else if (lpszPath[1] == ':' && lpszPath[2] == '\\' && lpszPath[3] == '\0')
1580       return TRUE; /* X:\ */
1581   }
1582   return FALSE;
1583 }
1584
1585 /*************************************************************************
1586  * PathIsRootW          [SHLWAPI.@]
1587  *
1588  * See PathIsRootA.
1589  */
1590 BOOL WINAPI PathIsRootW(LPCWSTR lpszPath)
1591 {
1592   TRACE("(%s)\n", debugstr_w(lpszPath));
1593
1594   if (lpszPath && *lpszPath)
1595   {
1596     if (*lpszPath == '\\')
1597     {
1598       if (!lpszPath[1])
1599         return TRUE; /* \ */
1600       else if (lpszPath[1]=='\\')
1601       {
1602         BOOL bSeenSlash = FALSE;
1603         lpszPath += 2;
1604
1605         /* Check for UNC root path */
1606         while (*lpszPath)
1607         {
1608           if (*lpszPath == '\\')
1609           {
1610             if (bSeenSlash)
1611               return FALSE;
1612             bSeenSlash = TRUE;
1613           }
1614           lpszPath++;
1615         }
1616         return TRUE;
1617       }
1618     }
1619     else if (lpszPath[1] == ':' && lpszPath[2] == '\\' && lpszPath[3] == '\0')
1620       return TRUE; /* X:\ */
1621   }
1622   return FALSE;
1623 }
1624
1625 /*************************************************************************
1626  * PathIsDirectoryA     [SHLWAPI.@]
1627  *
1628  * Determine if a path is a valid directory
1629  *
1630  * PARAMS
1631  *  lpszPath [I] Path to check.
1632  *
1633  * RETURNS
1634  *  FILE_ATTRIBUTE_DIRECTORY if lpszPath exists and can be read (See Notes)
1635  *  FALSE if lpszPath is invalid or not a directory.
1636  *
1637  * NOTES
1638  *  Although this function is prototyped as returning a BOOL, it returns
1639  *  FILE_ATTRIBUTE_DIRECTORY for success. This means that code such as:
1640  *
1641  *|  if (PathIsDirectoryA("c:\\windows\\") == TRUE)
1642  *|    ...
1643  *
1644  *  will always fail.
1645  */
1646 BOOL WINAPI PathIsDirectoryA(LPCSTR lpszPath)
1647 {
1648   DWORD dwAttr;
1649
1650   TRACE("(%s)\n", debugstr_a(lpszPath));
1651
1652   if (!lpszPath || PathIsUNCServerA(lpszPath))
1653     return FALSE;
1654
1655   if (PathIsUNCServerShareA(lpszPath))
1656   {
1657     FIXME("UNC Server Share not yet supported - FAILING\n");
1658     return FALSE;
1659   }
1660
1661   if ((dwAttr = GetFileAttributesA(lpszPath)) == INVALID_FILE_ATTRIBUTES)
1662     return FALSE;
1663   return dwAttr & FILE_ATTRIBUTE_DIRECTORY;
1664 }
1665
1666 /*************************************************************************
1667  * PathIsDirectoryW     [SHLWAPI.@]
1668  *
1669  * See PathIsDirectoryA.
1670  */
1671 BOOL WINAPI PathIsDirectoryW(LPCWSTR lpszPath)
1672 {
1673   DWORD dwAttr;
1674
1675   TRACE("(%s)\n", debugstr_w(lpszPath));
1676
1677   if (!lpszPath || PathIsUNCServerW(lpszPath))
1678     return FALSE;
1679
1680   if (PathIsUNCServerShareW(lpszPath))
1681   {
1682     FIXME("UNC Server Share not yet supported - FAILING\n");
1683     return FALSE;
1684   }
1685
1686   if ((dwAttr = GetFileAttributesW(lpszPath)) == INVALID_FILE_ATTRIBUTES)
1687     return FALSE;
1688   return dwAttr & FILE_ATTRIBUTE_DIRECTORY;
1689 }
1690
1691 /*************************************************************************
1692  * PathFileExistsA      [SHLWAPI.@]
1693  *
1694  * Determine if a file exists.
1695  *
1696  * PARAMS
1697  *  lpszPath [I] Path to check
1698  *
1699  * RETURNS
1700  *  TRUE  If the file exists and is readable
1701  *  FALSE Otherwise
1702  */
1703 BOOL WINAPI PathFileExistsA(LPCSTR lpszPath)
1704 {
1705   UINT iPrevErrMode;
1706   DWORD dwAttr;
1707
1708   TRACE("(%s)\n",debugstr_a(lpszPath));
1709
1710   if (!lpszPath)
1711     return FALSE;
1712
1713   /* Prevent a dialog box if path is on a disk that has been ejected. */
1714   iPrevErrMode = SetErrorMode(SEM_FAILCRITICALERRORS);
1715   dwAttr = GetFileAttributesA(lpszPath);
1716   SetErrorMode(iPrevErrMode);
1717   return dwAttr != INVALID_FILE_ATTRIBUTES;
1718 }
1719
1720 /*************************************************************************
1721  * PathFileExistsW      [SHLWAPI.@]
1722  *
1723  * See PathFileExistsA.
1724  */
1725 BOOL WINAPI PathFileExistsW(LPCWSTR lpszPath)
1726 {
1727   UINT iPrevErrMode;
1728   DWORD dwAttr;
1729
1730   TRACE("(%s)\n",debugstr_w(lpszPath));
1731
1732   if (!lpszPath)
1733     return FALSE;
1734
1735   iPrevErrMode = SetErrorMode(SEM_FAILCRITICALERRORS);
1736   dwAttr = GetFileAttributesW(lpszPath);
1737   SetErrorMode(iPrevErrMode);
1738   return dwAttr != INVALID_FILE_ATTRIBUTES;
1739 }
1740
1741 /*************************************************************************
1742  * PathFileExistsAndAttributesA [SHLWAPI.445]
1743  *
1744  * Determine if a file exists.
1745  *
1746  * PARAMS
1747  *  lpszPath [I] Path to check
1748  *  dwAttr   [O] attributes of file
1749  *
1750  * RETURNS
1751  *  TRUE  If the file exists and is readable
1752  *  FALSE Otherwise
1753  */
1754 BOOL WINAPI PathFileExistsAndAttributesA(LPCSTR lpszPath, DWORD *dwAttr)
1755 {
1756   UINT iPrevErrMode;
1757   DWORD dwVal = 0;
1758
1759   TRACE("(%s %p)\n", debugstr_a(lpszPath), dwAttr);
1760
1761   if (dwAttr)
1762     *dwAttr = INVALID_FILE_ATTRIBUTES;
1763
1764   if (!lpszPath)
1765     return FALSE;
1766
1767   iPrevErrMode = SetErrorMode(SEM_FAILCRITICALERRORS);
1768   dwVal = GetFileAttributesA(lpszPath);
1769   SetErrorMode(iPrevErrMode);
1770   if (dwAttr)
1771     *dwAttr = dwVal;
1772   return (dwVal != INVALID_FILE_ATTRIBUTES);
1773 }
1774
1775 /*************************************************************************
1776  * PathFileExistsAndAttributesW [SHLWAPI.446]
1777  *
1778  * See PathFileExistsA.
1779  */
1780 BOOL WINAPI PathFileExistsAndAttributesW(LPCWSTR lpszPath, DWORD *dwAttr)
1781 {
1782   UINT iPrevErrMode;
1783   DWORD dwVal;
1784
1785   TRACE("(%s %p)\n", debugstr_w(lpszPath), dwAttr);
1786
1787   if (!lpszPath)
1788     return FALSE;
1789
1790   iPrevErrMode = SetErrorMode(SEM_FAILCRITICALERRORS);
1791   dwVal = GetFileAttributesW(lpszPath);
1792   SetErrorMode(iPrevErrMode);
1793   if (dwAttr)
1794     *dwAttr = dwVal;
1795   return (dwVal != INVALID_FILE_ATTRIBUTES);
1796 }
1797
1798 /*************************************************************************
1799  * PathMatchSingleMaskA [internal]
1800  */
1801 static BOOL PathMatchSingleMaskA(LPCSTR name, LPCSTR mask)
1802 {
1803   while (*name && *mask && *mask!=';')
1804   {
1805     if (*mask == '*')
1806     {
1807       do
1808       {
1809         if (PathMatchSingleMaskA(name,mask+1))
1810           return TRUE;  /* try substrings */
1811       } while (*name++);
1812       return FALSE;
1813     }
1814
1815     if (toupper(*mask) != toupper(*name) && *mask != '?')
1816       return FALSE;
1817
1818     name = CharNextA(name);
1819     mask = CharNextA(mask);
1820   }
1821
1822   if (!*name)
1823   {
1824     while (*mask == '*')
1825       mask++;
1826     if (!*mask || *mask == ';')
1827       return TRUE;
1828   }
1829   return FALSE;
1830 }
1831
1832 /*************************************************************************
1833  * PathMatchSingleMaskW [internal]
1834  */
1835 static BOOL PathMatchSingleMaskW(LPCWSTR name, LPCWSTR mask)
1836 {
1837   while (*name && *mask && *mask != ';')
1838   {
1839     if (*mask == '*')
1840     {
1841       do
1842       {
1843         if (PathMatchSingleMaskW(name,mask+1))
1844           return TRUE;  /* try substrings */
1845       } while (*name++);
1846       return FALSE;
1847     }
1848
1849     if (toupperW(*mask) != toupperW(*name) && *mask != '?')
1850       return FALSE;
1851
1852     name++;
1853     mask++;
1854   }
1855   if (!*name)
1856   {
1857     while (*mask == '*')
1858       mask++;
1859     if (!*mask || *mask == ';')
1860       return TRUE;
1861   }
1862   return FALSE;
1863 }
1864
1865 /*************************************************************************
1866  * PathMatchSpecA       [SHLWAPI.@]
1867  *
1868  * Determine if a path matches one or more search masks.
1869  *
1870  * PARAMS
1871  *  lpszPath [I] Path to check
1872  *  lpszMask [I] Search mask(s)
1873  *
1874  * RETURNS
1875  *  TRUE  If lpszPath is valid and is matched
1876  *  FALSE Otherwise
1877  *
1878  * NOTES
1879  *  Multiple search masks may be given if they are separated by ";". The
1880  *  pattern "*.*" is treated specially in that it matches all paths (for
1881  *  backwards compatibility with DOS).
1882  */
1883 BOOL WINAPI PathMatchSpecA(LPCSTR lpszPath, LPCSTR lpszMask)
1884 {
1885   TRACE("(%s,%s)\n", lpszPath, lpszMask);
1886
1887   if (!lstrcmpA(lpszMask, "*.*"))
1888     return TRUE; /* Matches every path */
1889
1890   while (*lpszMask)
1891   {
1892     while (*lpszMask == ' ')
1893       lpszMask++; /* Eat leading spaces */
1894
1895     if (PathMatchSingleMaskA(lpszPath, lpszMask))
1896       return TRUE; /* Matches the current mask */
1897
1898     while (*lpszMask && *lpszMask != ';')
1899       lpszMask = CharNextA(lpszMask); /* masks separated by ';' */
1900
1901     if (*lpszMask == ';')
1902       lpszMask++;
1903   }
1904   return FALSE;
1905 }
1906
1907 /*************************************************************************
1908  * PathMatchSpecW       [SHLWAPI.@]
1909  *
1910  * See PathMatchSpecA.
1911  */
1912 BOOL WINAPI PathMatchSpecW(LPCWSTR lpszPath, LPCWSTR lpszMask)
1913 {
1914   static const WCHAR szStarDotStar[] = { '*', '.', '*', '\0' };
1915
1916   TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszMask));
1917
1918   if (!lstrcmpW(lpszMask, szStarDotStar))
1919     return TRUE; /* Matches every path */
1920
1921   while (*lpszMask)
1922   {
1923     while (*lpszMask == ' ')
1924       lpszMask++; /* Eat leading spaces */
1925
1926     if (PathMatchSingleMaskW(lpszPath, lpszMask))
1927       return TRUE; /* Matches the current path */
1928
1929     while (*lpszMask && *lpszMask != ';')
1930       lpszMask++; /* masks separated by ';' */
1931
1932     if (*lpszMask == ';')
1933       lpszMask++;
1934   }
1935   return FALSE;
1936 }
1937
1938 /*************************************************************************
1939  * PathIsSameRootA      [SHLWAPI.@]
1940  *
1941  * Determine if two paths share the same root.
1942  *
1943  * PARAMS
1944  *  lpszPath1 [I] Source path
1945  *  lpszPath2 [I] Path to compare with
1946  *
1947  * RETURNS
1948  *  TRUE  If both paths are valid and share the same root.
1949  *  FALSE If either path is invalid or the paths do not share the same root.
1950  */
1951 BOOL WINAPI PathIsSameRootA(LPCSTR lpszPath1, LPCSTR lpszPath2)
1952 {
1953   LPCSTR lpszStart;
1954   int dwLen;
1955
1956   TRACE("(%s,%s)\n", debugstr_a(lpszPath1), debugstr_a(lpszPath2));
1957
1958   if (!lpszPath1 || !lpszPath2 || !(lpszStart = PathSkipRootA(lpszPath1)))
1959     return FALSE;
1960
1961   dwLen = PathCommonPrefixA(lpszPath1, lpszPath2, NULL) + 1;
1962   if (lpszStart - lpszPath1 > dwLen)
1963     return FALSE; /* Paths not common up to length of the root */
1964   return TRUE;
1965 }
1966
1967 /*************************************************************************
1968  * PathIsSameRootW      [SHLWAPI.@]
1969  *
1970  * See PathIsSameRootA.
1971  */
1972 BOOL WINAPI PathIsSameRootW(LPCWSTR lpszPath1, LPCWSTR lpszPath2)
1973 {
1974   LPCWSTR lpszStart;
1975   int dwLen;
1976
1977   TRACE("(%s,%s)\n", debugstr_w(lpszPath1), debugstr_w(lpszPath2));
1978
1979   if (!lpszPath1 || !lpszPath2 || !(lpszStart = PathSkipRootW(lpszPath1)))
1980     return FALSE;
1981
1982   dwLen = PathCommonPrefixW(lpszPath1, lpszPath2, NULL) + 1;
1983   if (lpszStart - lpszPath1 > dwLen)
1984     return FALSE; /* Paths not common up to length of the root */
1985   return TRUE;
1986 }
1987
1988 /*************************************************************************
1989  * PathIsContentTypeA   [SHLWAPI.@]
1990  *
1991  * Determine if a file is of a given registered content type.
1992  *
1993  * PARAMS
1994  *  lpszPath        [I] File to check
1995  *  lpszContentType [I] Content type to check for
1996  *
1997  * RETURNS
1998  *  TRUE  If lpszPath is a given registered content type,
1999  *  FALSE Otherwise.
2000  *
2001  * NOTES
2002  *  This function looks up the registered content type for lpszPath. If
2003  *  a content type is registered, it is compared (case insensitively) to
2004  *  lpszContentType. Only if this matches does the function succeed.
2005  */
2006 BOOL WINAPI PathIsContentTypeA(LPCSTR lpszPath, LPCSTR lpszContentType)
2007 {
2008   LPCSTR szExt;
2009   DWORD dwDummy;
2010   char szBuff[MAX_PATH];
2011
2012   TRACE("(%s,%s)\n", debugstr_a(lpszPath), debugstr_a(lpszContentType));
2013
2014   if (lpszPath && (szExt = PathFindExtensionA(lpszPath)) && *szExt &&
2015       !SHGetValueA(HKEY_CLASSES_ROOT, szExt, "Content Type",
2016                    REG_NONE, szBuff, &dwDummy) &&
2017       !strcasecmp(lpszContentType, szBuff))
2018   {
2019     return TRUE;
2020   }
2021   return FALSE;
2022 }
2023
2024 /*************************************************************************
2025  * PathIsContentTypeW   [SHLWAPI.@]
2026  *
2027  * See PathIsContentTypeA.
2028  */
2029 BOOL WINAPI PathIsContentTypeW(LPCWSTR lpszPath, LPCWSTR lpszContentType)
2030 {
2031   static const WCHAR szContentType[] = { 'C','o','n','t','e','n','t',' ','T','y','p','e','\0' };
2032   LPCWSTR szExt;
2033   DWORD dwDummy;
2034   WCHAR szBuff[MAX_PATH];
2035
2036   TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszContentType));
2037
2038   if (lpszPath && (szExt = PathFindExtensionW(lpszPath)) && *szExt &&
2039       !SHGetValueW(HKEY_CLASSES_ROOT, szExt, szContentType,
2040                    REG_NONE, szBuff, &dwDummy) &&
2041       !strcmpiW(lpszContentType, szBuff))
2042   {
2043     return TRUE;
2044   }
2045   return FALSE;
2046 }
2047
2048 /*************************************************************************
2049  * PathIsFileSpecA   [SHLWAPI.@]
2050  *
2051  * Determine if a path is a file specification.
2052  *
2053  * PARAMS
2054  *  lpszPath [I] Path to check
2055  *
2056  * RETURNS
2057  *  TRUE  If lpszPath is a file specification (i.e. Contains no directories).
2058  *  FALSE Otherwise.
2059  */
2060 BOOL WINAPI PathIsFileSpecA(LPCSTR lpszPath)
2061 {
2062   TRACE("(%s)\n", debugstr_a(lpszPath));
2063
2064   if (!lpszPath)
2065     return FALSE;
2066
2067   while (*lpszPath)
2068   {
2069     if (*lpszPath == '\\' || *lpszPath == ':')
2070       return FALSE;
2071     lpszPath = CharNextA(lpszPath);
2072   }
2073   return TRUE;
2074 }
2075
2076 /*************************************************************************
2077  * PathIsFileSpecW   [SHLWAPI.@]
2078  *
2079  * See PathIsFileSpecA.
2080  */
2081 BOOL WINAPI PathIsFileSpecW(LPCWSTR lpszPath)
2082 {
2083   TRACE("(%s)\n", debugstr_w(lpszPath));
2084
2085   if (!lpszPath)
2086     return FALSE;
2087
2088   while (*lpszPath)
2089   {
2090     if (*lpszPath == '\\' || *lpszPath == ':')
2091       return FALSE;
2092     lpszPath++;
2093   }
2094   return TRUE;
2095 }
2096
2097 /*************************************************************************
2098  * PathIsPrefixA   [SHLWAPI.@]
2099  *
2100  * Determine if a path is a prefix of another.
2101  *
2102  * PARAMS
2103  *  lpszPrefix [I] Prefix
2104  *  lpszPath   [I] Path to check
2105  *
2106  * RETURNS
2107  *  TRUE  If lpszPath has lpszPrefix as its prefix,
2108  *  FALSE If either path is NULL or lpszPrefix is not a prefix
2109  */
2110 BOOL WINAPI PathIsPrefixA (LPCSTR lpszPrefix, LPCSTR lpszPath)
2111 {
2112   TRACE("(%s,%s)\n", debugstr_a(lpszPrefix), debugstr_a(lpszPath));
2113
2114   if (lpszPrefix && lpszPath &&
2115       PathCommonPrefixA(lpszPath, lpszPrefix, NULL) == (int)strlen(lpszPrefix))
2116     return TRUE;
2117   return FALSE;
2118 }
2119
2120 /*************************************************************************
2121  *  PathIsPrefixW   [SHLWAPI.@]
2122  *
2123  *  See PathIsPrefixA.
2124  */
2125 BOOL WINAPI PathIsPrefixW(LPCWSTR lpszPrefix, LPCWSTR lpszPath)
2126 {
2127   TRACE("(%s,%s)\n", debugstr_w(lpszPrefix), debugstr_w(lpszPath));
2128
2129   if (lpszPrefix && lpszPath &&
2130       PathCommonPrefixW(lpszPath, lpszPrefix, NULL) == (int)strlenW(lpszPrefix))
2131     return TRUE;
2132   return FALSE;
2133 }
2134
2135 /*************************************************************************
2136  * PathIsSystemFolderA   [SHLWAPI.@]
2137  *
2138  * Determine if a path or file attributes are a system folder.
2139  *
2140  * PARAMS
2141  *  lpszPath  [I] Path to check.
2142  *  dwAttrib  [I] Attributes to check, if lpszPath is NULL.
2143  *
2144  * RETURNS
2145  *  TRUE   If lpszPath or dwAttrib are a system folder.
2146  *  FALSE  If GetFileAttributesA() fails or neither parameter is a system folder.
2147  */
2148 BOOL WINAPI PathIsSystemFolderA(LPCSTR lpszPath, DWORD dwAttrib)
2149 {
2150   TRACE("(%s,0x%08x)\n", debugstr_a(lpszPath), dwAttrib);
2151
2152   if (lpszPath && *lpszPath)
2153     dwAttrib = GetFileAttributesA(lpszPath);
2154
2155   if (dwAttrib == INVALID_FILE_ATTRIBUTES || !(dwAttrib & FILE_ATTRIBUTE_DIRECTORY) ||
2156       !(dwAttrib & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)))
2157     return FALSE;
2158   return TRUE;
2159 }
2160
2161 /*************************************************************************
2162  * PathIsSystemFolderW   [SHLWAPI.@]
2163  *
2164  * See PathIsSystemFolderA.
2165  */
2166 BOOL WINAPI PathIsSystemFolderW(LPCWSTR lpszPath, DWORD dwAttrib)
2167 {
2168   TRACE("(%s,0x%08x)\n", debugstr_w(lpszPath), dwAttrib);
2169
2170   if (lpszPath && *lpszPath)
2171     dwAttrib = GetFileAttributesW(lpszPath);
2172
2173   if (dwAttrib == INVALID_FILE_ATTRIBUTES || !(dwAttrib & FILE_ATTRIBUTE_DIRECTORY) ||
2174       !(dwAttrib & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)))
2175     return FALSE;
2176   return TRUE;
2177 }
2178
2179 /*************************************************************************
2180  * PathIsUNCA           [SHLWAPI.@]
2181  *
2182  * Determine if a path is in UNC format.
2183  *
2184  * PARAMS
2185  *  lpszPath [I] Path to check
2186  *
2187  * RETURNS
2188  *  TRUE: The path is UNC.
2189  *  FALSE: The path is not UNC or is NULL.
2190  */
2191 BOOL WINAPI PathIsUNCA(LPCSTR lpszPath)
2192 {
2193   TRACE("(%s)\n",debugstr_a(lpszPath));
2194
2195   if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'))
2196     return TRUE;
2197   return FALSE;
2198 }
2199
2200 /*************************************************************************
2201  * PathIsUNCW           [SHLWAPI.@]
2202  *
2203  * See PathIsUNCA.
2204  */
2205 BOOL WINAPI PathIsUNCW(LPCWSTR lpszPath)
2206 {
2207   TRACE("(%s)\n",debugstr_w(lpszPath));
2208
2209   if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'))
2210     return TRUE;
2211   return FALSE;
2212 }
2213
2214 /*************************************************************************
2215  * PathIsUNCServerA   [SHLWAPI.@]
2216  *
2217  * Determine if a path is a UNC server name ("\\SHARENAME").
2218  *
2219  * PARAMS
2220  *  lpszPath  [I] Path to check.
2221  *
2222  * RETURNS
2223  *  TRUE   If lpszPath is a valid UNC server name.
2224  *  FALSE  Otherwise.
2225  *
2226  * NOTES
2227  *  This routine is bug compatible with Win32: Server names with a
2228  *  trailing backslash (e.g. "\\FOO\"), return FALSE incorrectly.
2229  *  Fixing this bug may break other shlwapi functions!
2230  */
2231 BOOL WINAPI PathIsUNCServerA(LPCSTR lpszPath)
2232 {
2233   TRACE("(%s)\n", debugstr_a(lpszPath));
2234
2235   if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
2236   {
2237     while (*lpszPath)
2238     {
2239       if (*lpszPath == '\\')
2240         return FALSE;
2241       lpszPath = CharNextA(lpszPath);
2242     }
2243     return TRUE;
2244   }
2245   return FALSE;
2246 }
2247
2248 /*************************************************************************
2249  * PathIsUNCServerW   [SHLWAPI.@]
2250  *
2251  * See PathIsUNCServerA.
2252  */
2253 BOOL WINAPI PathIsUNCServerW(LPCWSTR lpszPath)
2254 {
2255   TRACE("(%s)\n", debugstr_w(lpszPath));
2256
2257   if (lpszPath && lpszPath[0] == '\\' && lpszPath[1] == '\\')
2258   {
2259       return !strchrW( lpszPath + 2, '\\' );
2260   }
2261   return FALSE;
2262 }
2263
2264 /*************************************************************************
2265  * PathIsUNCServerShareA   [SHLWAPI.@]
2266  *
2267  * Determine if a path is a UNC server share ("\\SHARENAME\SHARE").
2268  *
2269  * PARAMS
2270  *  lpszPath  [I] Path to check.
2271  *
2272  * RETURNS
2273  *  TRUE   If lpszPath is a valid UNC server share.
2274  *  FALSE  Otherwise.
2275  *
2276  * NOTES
2277  *  This routine is bug compatible with Win32: Server shares with a
2278  *  trailing backslash (e.g. "\\FOO\BAR\"), return FALSE incorrectly.
2279  *  Fixing this bug may break other shlwapi functions!
2280  */
2281 BOOL WINAPI PathIsUNCServerShareA(LPCSTR lpszPath)
2282 {
2283   TRACE("(%s)\n", debugstr_a(lpszPath));
2284
2285   if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
2286   {
2287     BOOL bSeenSlash = FALSE;
2288     while (*lpszPath)
2289     {
2290       if (*lpszPath == '\\')
2291       {
2292         if (bSeenSlash)
2293           return FALSE;
2294         bSeenSlash = TRUE;
2295       }
2296       lpszPath = CharNextA(lpszPath);
2297     }
2298     return bSeenSlash;
2299   }
2300   return FALSE;
2301 }
2302
2303 /*************************************************************************
2304  * PathIsUNCServerShareW   [SHLWAPI.@]
2305  *
2306  * See PathIsUNCServerShareA.
2307  */
2308 BOOL WINAPI PathIsUNCServerShareW(LPCWSTR lpszPath)
2309 {
2310   TRACE("(%s)\n", debugstr_w(lpszPath));
2311
2312   if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
2313   {
2314     BOOL bSeenSlash = FALSE;
2315     while (*lpszPath)
2316     {
2317       if (*lpszPath == '\\')
2318       {
2319         if (bSeenSlash)
2320           return FALSE;
2321         bSeenSlash = TRUE;
2322       }
2323       lpszPath++;
2324     }
2325     return bSeenSlash;
2326   }
2327   return FALSE;
2328 }
2329
2330 /*************************************************************************
2331  * PathCanonicalizeA   [SHLWAPI.@]
2332  *
2333  * Convert a path to its canonical form.
2334  *
2335  * PARAMS
2336  *  lpszBuf  [O] Output path
2337  *  lpszPath [I] Path to canonicalize
2338  *
2339  * RETURNS
2340  *  Success: TRUE.  lpszBuf contains the output path,
2341  *  Failure: FALSE, If input path is invalid. lpszBuf is undefined
2342  */
2343 BOOL WINAPI PathCanonicalizeA(LPSTR lpszBuf, LPCSTR lpszPath)
2344 {
2345   BOOL bRet = FALSE;
2346
2347   TRACE("(%p,%s)\n", lpszBuf, debugstr_a(lpszPath));
2348
2349   if (lpszBuf)
2350     *lpszBuf = '\0';
2351
2352   if (!lpszBuf || !lpszPath)
2353     SetLastError(ERROR_INVALID_PARAMETER);
2354   else
2355   {
2356     WCHAR szPath[MAX_PATH];
2357     WCHAR szBuff[MAX_PATH];
2358     int ret = MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
2359
2360     if (!ret) {
2361         WARN("Failed to convert string to widechar (too long?), LE %d.\n", GetLastError());
2362         return FALSE;
2363     }
2364     bRet = PathCanonicalizeW(szBuff, szPath);
2365     WideCharToMultiByte(CP_ACP,0,szBuff,-1,lpszBuf,MAX_PATH,0,0);
2366   }
2367   return bRet;
2368 }
2369
2370
2371 /*************************************************************************
2372  * PathCanonicalizeW   [SHLWAPI.@]
2373  *
2374  * See PathCanonicalizeA.
2375  */
2376 BOOL WINAPI PathCanonicalizeW(LPWSTR lpszBuf, LPCWSTR lpszPath)
2377 {
2378   LPWSTR lpszDst = lpszBuf;
2379   LPCWSTR lpszSrc = lpszPath;
2380
2381   TRACE("(%p,%s)\n", lpszBuf, debugstr_w(lpszPath));
2382
2383   if (lpszBuf)
2384     *lpszDst = '\0';
2385
2386   if (!lpszBuf || !lpszPath)
2387   {
2388     SetLastError(ERROR_INVALID_PARAMETER);
2389     return FALSE;
2390   }
2391
2392   if (!*lpszPath)
2393   {
2394     *lpszBuf++ = '\\';
2395     *lpszBuf = '\0';
2396     return TRUE;
2397   }
2398
2399   /* Copy path root */
2400   if (*lpszSrc == '\\')
2401   {
2402     *lpszDst++ = *lpszSrc++;
2403   }
2404   else if (*lpszSrc && lpszSrc[1] == ':')
2405   {
2406     /* X:\ */
2407     *lpszDst++ = *lpszSrc++;
2408     *lpszDst++ = *lpszSrc++;
2409     if (*lpszSrc == '\\')
2410       *lpszDst++ = *lpszSrc++;
2411   }
2412
2413   /* Canonicalize the rest of the path */
2414   while (*lpszSrc)
2415   {
2416     if (*lpszSrc == '.')
2417     {
2418       if (lpszSrc[1] == '\\' && (lpszSrc == lpszPath || lpszSrc[-1] == '\\' || lpszSrc[-1] == ':'))
2419       {
2420         lpszSrc += 2; /* Skip .\ */
2421       }
2422       else if (lpszSrc[1] == '.' && (lpszDst == lpszBuf || lpszDst[-1] == '\\'))
2423       {
2424         /* \.. backs up a directory, over the root if it has no \ following X:.
2425          * .. is ignored if it would remove a UNC server name or initial \\
2426          */
2427         if (lpszDst != lpszBuf)
2428         {
2429           *lpszDst = '\0'; /* Allow PathIsUNCServerShareA test on lpszBuf */
2430           if (lpszDst > lpszBuf+1 && lpszDst[-1] == '\\' &&
2431              (lpszDst[-2] != '\\' || lpszDst > lpszBuf+2))
2432           {
2433             if (lpszDst[-2] == ':' && (lpszDst > lpszBuf+3 || lpszDst[-3] == ':'))
2434             {
2435               lpszDst -= 2;
2436               while (lpszDst > lpszBuf && *lpszDst != '\\')
2437                 lpszDst--;
2438               if (*lpszDst == '\\')
2439                 lpszDst++; /* Reset to last '\' */
2440               else
2441                 lpszDst = lpszBuf; /* Start path again from new root */
2442             }
2443             else if (lpszDst[-2] != ':' && !PathIsUNCServerShareW(lpszBuf))
2444               lpszDst -= 2;
2445           }
2446           while (lpszDst > lpszBuf && *lpszDst != '\\')
2447             lpszDst--;
2448           if (lpszDst == lpszBuf)
2449           {
2450             *lpszDst++ = '\\';
2451             lpszSrc++;
2452           }
2453         }
2454         lpszSrc += 2; /* Skip .. in src path */
2455       }
2456       else
2457         *lpszDst++ = *lpszSrc++;
2458     }
2459     else
2460       *lpszDst++ = *lpszSrc++;
2461   }
2462   /* Append \ to naked drive specs */
2463   if (lpszDst - lpszBuf == 2 && lpszDst[-1] == ':')
2464     *lpszDst++ = '\\';
2465   *lpszDst++ = '\0';
2466   return TRUE;
2467 }
2468
2469 /*************************************************************************
2470  * PathFindNextComponentA   [SHLWAPI.@]
2471  *
2472  * Find the next component in a path.
2473  *
2474  * PARAMS
2475  *   lpszPath [I] Path to find next component in
2476  *
2477  * RETURNS
2478  *  Success: A pointer to the next component, or the end of the string.
2479  *  Failure: NULL, If lpszPath is invalid
2480  *
2481  * NOTES
2482  *  A 'component' is either a backslash character (\) or UNC marker (\\).
2483  *  Because of this, relative paths (e.g "c:foo") are regarded as having
2484  *  only one component.
2485  */
2486 LPSTR WINAPI PathFindNextComponentA(LPCSTR lpszPath)
2487 {
2488   LPSTR lpszSlash;
2489
2490   TRACE("(%s)\n", debugstr_a(lpszPath));
2491
2492   if(!lpszPath || !*lpszPath)
2493     return NULL;
2494
2495   if ((lpszSlash = StrChrA(lpszPath, '\\')))
2496   {
2497     if (lpszSlash[1] == '\\')
2498       lpszSlash++;
2499     return lpszSlash + 1;
2500   }
2501   return (LPSTR)lpszPath + strlen(lpszPath);
2502 }
2503
2504 /*************************************************************************
2505  * PathFindNextComponentW   [SHLWAPI.@]
2506  *
2507  * See PathFindNextComponentA.
2508  */
2509 LPWSTR WINAPI PathFindNextComponentW(LPCWSTR lpszPath)
2510 {
2511   LPWSTR lpszSlash;
2512
2513   TRACE("(%s)\n", debugstr_w(lpszPath));
2514
2515   if(!lpszPath || !*lpszPath)
2516     return NULL;
2517
2518   if ((lpszSlash = StrChrW(lpszPath, '\\')))
2519   {
2520     if (lpszSlash[1] == '\\')
2521       lpszSlash++;
2522     return lpszSlash + 1;
2523   }
2524   return (LPWSTR)lpszPath + strlenW(lpszPath);
2525 }
2526
2527 /*************************************************************************
2528  * PathAddExtensionA   [SHLWAPI.@]
2529  *
2530  * Add a file extension to a path
2531  *
2532  * PARAMS
2533  *  lpszPath      [I/O] Path to add extension to
2534  *  lpszExtension [I]   Extension to add to lpszPath
2535  *
2536  * RETURNS
2537  *  TRUE  If the path was modified,
2538  *  FALSE If lpszPath or lpszExtension are invalid, lpszPath has an
2539  *        extension already, or the new path length is too big.
2540  *
2541  * FIXME
2542  *  What version of shlwapi.dll adds "exe" if lpszExtension is NULL? Win2k
2543  *  does not do this, so the behaviour was removed.
2544  */
2545 BOOL WINAPI PathAddExtensionA(LPSTR lpszPath, LPCSTR lpszExtension)
2546 {
2547   size_t dwLen;
2548
2549   TRACE("(%s,%s)\n", debugstr_a(lpszPath), debugstr_a(lpszExtension));
2550
2551   if (!lpszPath || !lpszExtension || *(PathFindExtensionA(lpszPath)))
2552     return FALSE;
2553
2554   dwLen = strlen(lpszPath);
2555
2556   if (dwLen + strlen(lpszExtension) >= MAX_PATH)
2557     return FALSE;
2558
2559   strcpy(lpszPath + dwLen, lpszExtension);
2560   return TRUE;
2561 }
2562
2563 /*************************************************************************
2564  * PathAddExtensionW   [SHLWAPI.@]
2565  *
2566  * See PathAddExtensionA.
2567  */
2568 BOOL WINAPI PathAddExtensionW(LPWSTR lpszPath, LPCWSTR lpszExtension)
2569 {
2570   size_t dwLen;
2571
2572   TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszExtension));
2573
2574   if (!lpszPath || !lpszExtension || *(PathFindExtensionW(lpszPath)))
2575     return FALSE;
2576
2577   dwLen = strlenW(lpszPath);
2578
2579   if (dwLen + strlenW(lpszExtension) >= MAX_PATH)
2580     return FALSE;
2581
2582   strcpyW(lpszPath + dwLen, lpszExtension);
2583   return TRUE;
2584 }
2585
2586 /*************************************************************************
2587  * PathMakePrettyA   [SHLWAPI.@]
2588  *
2589  * Convert an uppercase DOS filename into lowercase.
2590  *
2591  * PARAMS
2592  *  lpszPath [I/O] Path to convert.
2593  *
2594  * RETURNS
2595  *  TRUE  If the path was an uppercase DOS path and was converted,
2596  *  FALSE Otherwise.
2597  */
2598 BOOL WINAPI PathMakePrettyA(LPSTR lpszPath)
2599 {
2600   LPSTR pszIter = lpszPath;
2601
2602   TRACE("(%s)\n", debugstr_a(lpszPath));
2603
2604   if (!pszIter)
2605     return FALSE;
2606
2607   if (*pszIter)
2608   {
2609     do
2610     {
2611       if (islower(*pszIter) || IsDBCSLeadByte(*pszIter))
2612         return FALSE; /* Not DOS path */
2613       pszIter++;
2614     } while (*pszIter);
2615     pszIter = lpszPath + 1;
2616     while (*pszIter)
2617     {
2618       *pszIter = tolower(*pszIter);
2619       pszIter++;
2620     }
2621   }
2622   return TRUE;
2623 }
2624
2625 /*************************************************************************
2626  * PathMakePrettyW   [SHLWAPI.@]
2627  *
2628  * See PathMakePrettyA.
2629  */
2630 BOOL WINAPI PathMakePrettyW(LPWSTR lpszPath)
2631 {
2632   LPWSTR pszIter = lpszPath;
2633
2634   TRACE("(%s)\n", debugstr_w(lpszPath));
2635
2636   if (!pszIter)
2637     return FALSE;
2638
2639   if (*pszIter)
2640   {
2641     do
2642     {
2643       if (islowerW(*pszIter))
2644         return FALSE; /* Not DOS path */
2645       pszIter++;
2646     } while (*pszIter);
2647     pszIter = lpszPath + 1;
2648     while (*pszIter)
2649     {
2650       *pszIter = tolowerW(*pszIter);
2651       pszIter++;
2652     }
2653   }
2654   return TRUE;
2655 }
2656
2657 /*************************************************************************
2658  * PathCommonPrefixA   [SHLWAPI.@]
2659  *
2660  * Determine the length of the common prefix between two paths.
2661  *
2662  * PARAMS
2663  *  lpszFile1 [I] First path for comparison
2664  *  lpszFile2 [I] Second path for comparison
2665  *  achPath   [O] Destination for common prefix string
2666  *
2667  * RETURNS
2668  *  The length of the common prefix. This is 0 if there is no common
2669  *  prefix between the paths or if any parameters are invalid. If the prefix
2670  *  is non-zero and achPath is not NULL, achPath is filled with the common
2671  *  part of the prefix and NUL terminated.
2672  *
2673  * NOTES
2674  *  A common prefix of 2 is always returned as 3. It is thus possible for
2675  *  the length returned to be invalid (i.e. Longer than one or both of the
2676  *  strings given as parameters). This Win32 behaviour has been implemented
2677  *  here, and cannot be changed (fixed?) without breaking other SHLWAPI calls.
2678  *  To work around this when using this function, always check that the byte
2679  *  at [common_prefix_len-1] is not a NUL. If it is, deduct 1 from the prefix.
2680  */
2681 int WINAPI PathCommonPrefixA(LPCSTR lpszFile1, LPCSTR lpszFile2, LPSTR achPath)
2682 {
2683   size_t iLen = 0;
2684   LPCSTR lpszIter1 = lpszFile1;
2685   LPCSTR lpszIter2 = lpszFile2;
2686
2687   TRACE("(%s,%s,%p)\n", debugstr_a(lpszFile1), debugstr_a(lpszFile2), achPath);
2688
2689   if (achPath)
2690     *achPath = '\0';
2691
2692   if (!lpszFile1 || !lpszFile2)
2693     return 0;
2694
2695   /* Handle roots first */
2696   if (PathIsUNCA(lpszFile1))
2697   {
2698     if (!PathIsUNCA(lpszFile2))
2699       return 0;
2700     lpszIter1 += 2;
2701     lpszIter2 += 2;
2702   }
2703   else if (PathIsUNCA(lpszFile2))
2704       return 0; /* Know already lpszFile1 is not UNC */
2705
2706   do
2707   {
2708     /* Update len */
2709     if ((!*lpszIter1 || *lpszIter1 == '\\') &&
2710         (!*lpszIter2 || *lpszIter2 == '\\'))
2711       iLen = lpszIter1 - lpszFile1; /* Common to this point */
2712
2713     if (!*lpszIter1 || (tolower(*lpszIter1) != tolower(*lpszIter2)))
2714       break; /* Strings differ at this point */
2715
2716     lpszIter1++;
2717     lpszIter2++;
2718   } while (1);
2719
2720   if (iLen == 2)
2721     iLen++; /* Feature/Bug compatible with Win32 */
2722
2723   if (iLen && achPath)
2724   {
2725     memcpy(achPath,lpszFile1,iLen);
2726     achPath[iLen] = '\0';
2727   }
2728   return iLen;
2729 }
2730
2731 /*************************************************************************
2732  * PathCommonPrefixW   [SHLWAPI.@]
2733  *
2734  * See PathCommonPrefixA.
2735  */
2736 int WINAPI PathCommonPrefixW(LPCWSTR lpszFile1, LPCWSTR lpszFile2, LPWSTR achPath)
2737 {
2738   size_t iLen = 0;
2739   LPCWSTR lpszIter1 = lpszFile1;
2740   LPCWSTR lpszIter2 = lpszFile2;
2741
2742   TRACE("(%s,%s,%p)\n", debugstr_w(lpszFile1), debugstr_w(lpszFile2), achPath);
2743
2744   if (achPath)
2745     *achPath = '\0';
2746
2747   if (!lpszFile1 || !lpszFile2)
2748     return 0;
2749
2750   /* Handle roots first */
2751   if (PathIsUNCW(lpszFile1))
2752   {
2753     if (!PathIsUNCW(lpszFile2))
2754       return 0;
2755     lpszIter1 += 2;
2756     lpszIter2 += 2;
2757   }
2758   else if (PathIsUNCW(lpszFile2))
2759       return 0; /* Know already lpszFile1 is not UNC */
2760
2761   do
2762   {
2763     /* Update len */
2764     if ((!*lpszIter1 || *lpszIter1 == '\\') &&
2765         (!*lpszIter2 || *lpszIter2 == '\\'))
2766       iLen = lpszIter1 - lpszFile1; /* Common to this point */
2767
2768     if (!*lpszIter1 || (tolowerW(*lpszIter1) != tolowerW(*lpszIter2)))
2769       break; /* Strings differ at this point */
2770
2771     lpszIter1++;
2772     lpszIter2++;
2773   } while (1);
2774
2775   if (iLen == 2)
2776     iLen++; /* Feature/Bug compatible with Win32 */
2777
2778   if (iLen && achPath)
2779   {
2780     memcpy(achPath,lpszFile1,iLen * sizeof(WCHAR));
2781     achPath[iLen] = '\0';
2782   }
2783   return iLen;
2784 }
2785
2786 /*************************************************************************
2787  * PathCompactPathA   [SHLWAPI.@]
2788  *
2789  * Make a path fit into a given width when printed to a DC.
2790  *
2791  * PARAMS
2792  *  hDc      [I]   Destination DC
2793  *  lpszPath [I/O] Path to be printed to hDc
2794  *  dx       [I]   Desired width
2795  *
2796  * RETURNS
2797  *  TRUE  If the path was modified/went well.
2798  *  FALSE Otherwise.
2799  */
2800 BOOL WINAPI PathCompactPathA(HDC hDC, LPSTR lpszPath, UINT dx)
2801 {
2802   BOOL bRet = FALSE;
2803
2804   TRACE("(%p,%s,%d)\n", hDC, debugstr_a(lpszPath), dx);
2805
2806   if (lpszPath)
2807   {
2808     WCHAR szPath[MAX_PATH];
2809     MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
2810     bRet = PathCompactPathW(hDC, szPath, dx);
2811     WideCharToMultiByte(CP_ACP,0,szPath,-1,lpszPath,MAX_PATH,0,0);
2812   }
2813   return bRet;
2814 }
2815
2816 /*************************************************************************
2817  * PathCompactPathW   [SHLWAPI.@]
2818  *
2819  * See PathCompactPathA.
2820  */
2821 BOOL WINAPI PathCompactPathW(HDC hDC, LPWSTR lpszPath, UINT dx)
2822 {
2823   static const WCHAR szEllipses[] = { '.', '.', '.', '\0' };
2824   BOOL bRet = TRUE;
2825   HDC hdc = 0;
2826   WCHAR buff[MAX_PATH];
2827   SIZE size;
2828   DWORD dwLen;
2829
2830   TRACE("(%p,%s,%d)\n", hDC, debugstr_w(lpszPath), dx);
2831
2832   if (!lpszPath)
2833     return FALSE;
2834
2835   if (!hDC)
2836     hdc = hDC = GetDC(0);
2837
2838   /* Get the length of the whole path */
2839   dwLen = strlenW(lpszPath);
2840   GetTextExtentPointW(hDC, lpszPath, dwLen, &size);
2841
2842   if ((UINT)size.cx > dx)
2843   {
2844     /* Path too big, must reduce it */
2845     LPWSTR sFile;
2846     DWORD dwEllipsesLen = 0, dwPathLen = 0;
2847
2848     sFile = PathFindFileNameW(lpszPath);
2849     if (sFile != lpszPath) sFile--;
2850
2851     /* Get the size of ellipses */
2852     GetTextExtentPointW(hDC, szEllipses, 3, &size);
2853     dwEllipsesLen = size.cx;
2854     /* Get the size of the file name */
2855     GetTextExtentPointW(hDC, sFile, strlenW(sFile), &size);
2856     dwPathLen = size.cx;
2857
2858     if (sFile != lpszPath)
2859     {
2860       LPWSTR sPath = sFile;
2861       BOOL bEllipses = FALSE;
2862
2863       /* The path includes a file name. Include as much of the path prior to
2864        * the file name as possible, allowing for the ellipses, e.g:
2865        * c:\some very long path\filename ==> c:\some v...\filename
2866        */
2867       lstrcpynW(buff, sFile, MAX_PATH);
2868
2869       do
2870       {
2871         DWORD dwTotalLen = bEllipses? dwPathLen + dwEllipsesLen : dwPathLen;
2872
2873         GetTextExtentPointW(hDC, lpszPath, sPath - lpszPath, &size);
2874         dwTotalLen += size.cx;
2875         if (dwTotalLen <= dx)
2876           break;
2877         sPath--;
2878         if (!bEllipses)
2879         {
2880           bEllipses = TRUE;
2881           sPath -= 2;
2882         }
2883       } while (sPath > lpszPath);
2884
2885       if (sPath > lpszPath)
2886       {
2887         if (bEllipses)
2888         {
2889           strcpyW(sPath, szEllipses);
2890           strcpyW(sPath+3, buff);
2891         }
2892         bRet = TRUE;
2893         goto end;
2894       }
2895       strcpyW(lpszPath, szEllipses);
2896       strcpyW(lpszPath+3, buff);
2897       bRet = FALSE;
2898       goto end;
2899     }
2900
2901     /* Trim the path by adding ellipses to the end, e.g:
2902      * A very long file name.txt ==> A very...
2903      */
2904     dwLen = strlenW(lpszPath);
2905
2906     if (dwLen > MAX_PATH - 3)
2907       dwLen =  MAX_PATH - 3;
2908     lstrcpynW(buff, sFile, dwLen);
2909
2910     do {
2911       dwLen--;
2912       GetTextExtentPointW(hDC, buff, dwLen, &size);
2913     } while (dwLen && size.cx + dwEllipsesLen > dx);
2914
2915    if (!dwLen)
2916    {
2917      DWORD dwWritten = 0;
2918
2919      dwEllipsesLen /= 3; /* Size of a single '.' */
2920
2921      /* Write as much of the Ellipses string as possible */
2922      while (dwWritten + dwEllipsesLen < dx && dwLen < 3)
2923      {
2924        *lpszPath++ = '.';
2925        dwWritten += dwEllipsesLen;
2926        dwLen++;
2927      }
2928      *lpszPath = '\0';
2929      bRet = FALSE;
2930    }
2931    else
2932    {
2933      strcpyW(buff + dwLen, szEllipses);
2934      strcpyW(lpszPath, buff);
2935     }
2936   }
2937
2938 end:
2939   if (hdc)
2940     ReleaseDC(0, hdc);
2941
2942   return bRet;
2943 }
2944
2945 /*************************************************************************
2946  * PathGetCharTypeA   [SHLWAPI.@]
2947  *
2948  * Categorise a character from a file path.
2949  *
2950  * PARAMS
2951  *  ch [I] Character to get the type of
2952  *
2953  * RETURNS
2954  *  A set of GCT_ bit flags (from "shlwapi.h") indicating the character type.
2955  */
2956 UINT WINAPI PathGetCharTypeA(UCHAR ch)
2957 {
2958   return PathGetCharTypeW(ch);
2959 }
2960
2961 /*************************************************************************
2962  * PathGetCharTypeW   [SHLWAPI.@]
2963  *
2964  * See PathGetCharTypeA.
2965  */
2966 UINT WINAPI PathGetCharTypeW(WCHAR ch)
2967 {
2968   UINT flags = 0;
2969
2970   TRACE("(%d)\n", ch);
2971
2972   if (!ch || ch < ' ' || ch == '<' || ch == '>' ||
2973       ch == '"' || ch == '|' || ch == '/')
2974     flags = GCT_INVALID; /* Invalid */
2975   else if (ch == '*' || ch=='?')
2976     flags = GCT_WILD; /* Wildchars */
2977   else if ((ch == '\\') || (ch == ':'))
2978     return GCT_SEPARATOR; /* Path separators */
2979   else
2980   {
2981      if (ch < 126)
2982      {
2983          if (((ch & 0x1) && ch != ';') || !ch || isalnum(ch) || ch == '$' || ch == '&' || ch == '(' ||
2984             ch == '.' || ch == '@' || ch == '^' ||
2985             ch == '\'' || ch == 130 || ch == '`')
2986          flags |= GCT_SHORTCHAR; /* All these are valid for DOS */
2987      }
2988      else
2989        flags |= GCT_SHORTCHAR; /* Bug compatible with win32 */
2990      flags |= GCT_LFNCHAR; /* Valid for long file names */
2991   }
2992   return flags;
2993 }
2994
2995 /*************************************************************************
2996  * SHLWAPI_UseSystemForSystemFolders
2997  *
2998  * Internal helper for PathMakeSystemFolderW.
2999  */
3000 static BOOL SHLWAPI_UseSystemForSystemFolders(void)
3001 {
3002   static BOOL bCheckedReg = FALSE;
3003   static BOOL bUseSystemForSystemFolders = FALSE;
3004
3005   if (!bCheckedReg)
3006   {
3007     bCheckedReg = TRUE;
3008
3009     /* Key tells Win what file attributes to use on system folders */
3010     if (SHGetValueA(HKEY_LOCAL_MACHINE,
3011         "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer",
3012         "UseSystemForSystemFolders", 0, 0, 0))
3013       bUseSystemForSystemFolders = TRUE;
3014   }
3015   return bUseSystemForSystemFolders;
3016 }
3017
3018 /*************************************************************************
3019  * PathMakeSystemFolderA   [SHLWAPI.@]
3020  *
3021  * Set system folder attribute for a path.
3022  *
3023  * PARAMS
3024  *  lpszPath [I] The path to turn into a system folder
3025  *
3026  * RETURNS
3027  *  TRUE  If the path was changed to/already was a system folder
3028  *  FALSE If the path is invalid or SetFileAttributesA() fails
3029  */
3030 BOOL WINAPI PathMakeSystemFolderA(LPCSTR lpszPath)
3031 {
3032   BOOL bRet = FALSE;
3033
3034   TRACE("(%s)\n", debugstr_a(lpszPath));
3035
3036   if (lpszPath && *lpszPath)
3037   {
3038     WCHAR szPath[MAX_PATH];
3039     MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
3040     bRet = PathMakeSystemFolderW(szPath);
3041   }
3042   return bRet;
3043 }
3044
3045 /*************************************************************************
3046  * PathMakeSystemFolderW   [SHLWAPI.@]
3047  *
3048  * See PathMakeSystemFolderA.
3049  */
3050 BOOL WINAPI PathMakeSystemFolderW(LPCWSTR lpszPath)
3051 {
3052   DWORD dwDefaultAttr = FILE_ATTRIBUTE_READONLY, dwAttr;
3053   WCHAR buff[MAX_PATH];
3054
3055   TRACE("(%s)\n", debugstr_w(lpszPath));
3056
3057   if (!lpszPath || !*lpszPath)
3058     return FALSE;
3059
3060   /* If the directory is already a system directory, don't do anything */
3061   GetSystemDirectoryW(buff, MAX_PATH);
3062   if (!strcmpW(buff, lpszPath))
3063     return TRUE;
3064
3065   GetWindowsDirectoryW(buff, MAX_PATH);
3066   if (!strcmpW(buff, lpszPath))
3067     return TRUE;
3068
3069   /* "UseSystemForSystemFolders" Tells Win what attributes to use */
3070   if (SHLWAPI_UseSystemForSystemFolders())
3071     dwDefaultAttr = FILE_ATTRIBUTE_SYSTEM;
3072
3073   if ((dwAttr = GetFileAttributesW(lpszPath)) == INVALID_FILE_ATTRIBUTES)
3074     return FALSE;
3075
3076   /* Change file attributes to system attributes */
3077   dwAttr &= ~(FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_READONLY);
3078   return SetFileAttributesW(lpszPath, dwAttr | dwDefaultAttr);
3079 }
3080
3081 /*************************************************************************
3082  * PathRenameExtensionA   [SHLWAPI.@]
3083  *
3084  * Swap the file extension in a path with another extension.
3085  *
3086  * PARAMS
3087  *  lpszPath [I/O] Path to swap the extension in
3088  *  lpszExt  [I]   The new extension
3089  *
3090  * RETURNS
3091  *  TRUE  if lpszPath was modified,
3092  *  FALSE if lpszPath or lpszExt is NULL, or the new path is too long
3093  */
3094 BOOL WINAPI PathRenameExtensionA(LPSTR lpszPath, LPCSTR lpszExt)
3095 {
3096   LPSTR lpszExtension;
3097
3098   TRACE("(%s,%s)\n", debugstr_a(lpszPath), debugstr_a(lpszExt));
3099
3100   lpszExtension = PathFindExtensionA(lpszPath);
3101
3102   if (!lpszExtension || (lpszExtension - lpszPath + strlen(lpszExt) >= MAX_PATH))
3103     return FALSE;
3104
3105   strcpy(lpszExtension, lpszExt);
3106   return TRUE;
3107 }
3108
3109 /*************************************************************************
3110  * PathRenameExtensionW   [SHLWAPI.@]
3111  *
3112  * See PathRenameExtensionA.
3113  */
3114 BOOL WINAPI PathRenameExtensionW(LPWSTR lpszPath, LPCWSTR lpszExt)
3115 {
3116   LPWSTR lpszExtension;
3117
3118   TRACE("(%s,%s)\n", debugstr_w(lpszPath), debugstr_w(lpszExt));
3119
3120   lpszExtension = PathFindExtensionW(lpszPath);
3121
3122   if (!lpszExtension || (lpszExtension - lpszPath + strlenW(lpszExt) >= MAX_PATH))
3123     return FALSE;
3124
3125   strcpyW(lpszExtension, lpszExt);
3126   return TRUE;
3127 }
3128
3129 /*************************************************************************
3130  * PathSearchAndQualifyA   [SHLWAPI.@]
3131  *
3132  * Determine if a given path is correct and fully qualified.
3133  *
3134  * PARAMS
3135  *  lpszPath [I] Path to check
3136  *  lpszBuf  [O] Output for correct path
3137  *  cchBuf   [I] Size of lpszBuf
3138  *
3139  * RETURNS
3140  *  Unknown.
3141  */
3142 BOOL WINAPI PathSearchAndQualifyA(LPCSTR lpszPath, LPSTR lpszBuf, UINT cchBuf)
3143 {
3144     TRACE("(%s,%p,0x%08x)\n", debugstr_a(lpszPath), lpszBuf, cchBuf);
3145
3146     if(SearchPathA(NULL, lpszPath, NULL, cchBuf, lpszBuf, NULL))
3147         return TRUE;
3148     return !!GetFullPathNameA(lpszPath, cchBuf, lpszBuf, NULL);
3149 }
3150
3151 /*************************************************************************
3152  * PathSearchAndQualifyW   [SHLWAPI.@]
3153  *
3154  * See PathSearchAndQualifyA.
3155  */
3156 BOOL WINAPI PathSearchAndQualifyW(LPCWSTR lpszPath, LPWSTR lpszBuf, UINT cchBuf)
3157 {
3158     TRACE("(%s,%p,0x%08x)\n", debugstr_w(lpszPath), lpszBuf, cchBuf);
3159
3160     if(SearchPathW(NULL, lpszPath, NULL, cchBuf, lpszBuf, NULL))
3161         return TRUE;
3162     return !!GetFullPathNameW(lpszPath, cchBuf, lpszBuf, NULL);
3163 }
3164
3165 /*************************************************************************
3166  * PathSkipRootA   [SHLWAPI.@]
3167  *
3168  * Return the portion of a path following the drive letter or mount point.
3169  *
3170  * PARAMS
3171  *  lpszPath [I] The path to skip on
3172  *
3173  * RETURNS
3174  *  Success: A pointer to the next character after the root.
3175  *  Failure: NULL, if lpszPath is invalid, has no root or is a multibyte string.
3176  */
3177 LPSTR WINAPI PathSkipRootA(LPCSTR lpszPath)
3178 {
3179   TRACE("(%s)\n", debugstr_a(lpszPath));
3180
3181   if (!lpszPath || !*lpszPath)
3182     return NULL;
3183
3184   if (*lpszPath == '\\' && lpszPath[1] == '\\')
3185   {
3186     /* Network share: skip share server and mount point */
3187     lpszPath += 2;
3188     if ((lpszPath = StrChrA(lpszPath, '\\')) &&
3189         (lpszPath = StrChrA(lpszPath + 1, '\\')))
3190       lpszPath++;
3191     return (LPSTR)lpszPath;
3192   }
3193
3194   if (IsDBCSLeadByte(*lpszPath))
3195     return NULL;
3196
3197   /* Check x:\ */
3198   if (lpszPath[0] && lpszPath[1] == ':' && lpszPath[2] == '\\')
3199     return (LPSTR)lpszPath + 3;
3200   return NULL;
3201 }
3202
3203 /*************************************************************************
3204  * PathSkipRootW   [SHLWAPI.@]
3205  *
3206  * See PathSkipRootA.
3207  */
3208 LPWSTR WINAPI PathSkipRootW(LPCWSTR lpszPath)
3209 {
3210   TRACE("(%s)\n", debugstr_w(lpszPath));
3211
3212   if (!lpszPath || !*lpszPath)
3213     return NULL;
3214
3215   if (*lpszPath == '\\' && lpszPath[1] == '\\')
3216   {
3217     /* Network share: skip share server and mount point */
3218     lpszPath += 2;
3219     if ((lpszPath = StrChrW(lpszPath, '\\')) &&
3220         (lpszPath = StrChrW(lpszPath + 1, '\\')))
3221      lpszPath++;
3222     return (LPWSTR)lpszPath;
3223   }
3224
3225   /* Check x:\ */
3226   if (lpszPath[0] && lpszPath[1] == ':' && lpszPath[2] == '\\')
3227     return (LPWSTR)lpszPath + 3;
3228   return NULL;
3229 }
3230
3231 /*************************************************************************
3232  * PathCreateFromUrlA   [SHLWAPI.@]
3233  *
3234  * See PathCreateFromUrlW
3235  */
3236 HRESULT WINAPI PathCreateFromUrlA(LPCSTR pszUrl, LPSTR pszPath,
3237                                   LPDWORD pcchPath, DWORD dwReserved)
3238 {
3239     WCHAR bufW[MAX_PATH];
3240     WCHAR *pathW = bufW;
3241     UNICODE_STRING urlW;
3242     HRESULT ret;
3243     DWORD lenW = sizeof(bufW)/sizeof(WCHAR), lenA;
3244
3245     if(!RtlCreateUnicodeStringFromAsciiz(&urlW, pszUrl))
3246         return E_INVALIDARG;
3247     if((ret = PathCreateFromUrlW(urlW.Buffer, pathW, &lenW, dwReserved)) == E_POINTER) {
3248         pathW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR));
3249         ret = PathCreateFromUrlW(urlW.Buffer, pathW, &lenW, dwReserved);
3250     }
3251     if(ret == S_OK) {
3252         RtlUnicodeToMultiByteSize(&lenA, pathW, lenW * sizeof(WCHAR));
3253         if(*pcchPath > lenA) {
3254             RtlUnicodeToMultiByteN(pszPath, *pcchPath - 1, &lenA, pathW, lenW * sizeof(WCHAR));
3255             pszPath[lenA] = 0;
3256             *pcchPath = lenA;
3257         } else {
3258             *pcchPath = lenA + 1;
3259             ret = E_POINTER;
3260         }
3261     }
3262     if(pathW != bufW) HeapFree(GetProcessHeap(), 0, pathW);
3263     RtlFreeUnicodeString(&urlW);
3264     return ret;
3265 }
3266
3267 /*************************************************************************
3268  * PathCreateFromUrlW   [SHLWAPI.@]
3269  *
3270  * Create a path from a URL
3271  *
3272  * PARAMS
3273  *  lpszUrl  [I] URL to convert into a path
3274  *  lpszPath [O] Output buffer for the resulting Path
3275  *  pcchPath [I] Length of lpszPath
3276  *  dwFlags  [I] Flags controlling the conversion
3277  *
3278  * RETURNS
3279  *  Success: S_OK. lpszPath contains the URL in path format,
3280  *  Failure: An HRESULT error code such as E_INVALIDARG.
3281  */
3282 HRESULT WINAPI PathCreateFromUrlW(LPCWSTR pszUrl, LPWSTR pszPath,
3283                                   LPDWORD pcchPath, DWORD dwReserved)
3284 {
3285     static const WCHAR file_colon[] = { 'f','i','l','e',':',0 };
3286     HRESULT hr;
3287     DWORD nslashes = 0;
3288     WCHAR *ptr;
3289
3290     TRACE("(%s,%p,%p,0x%08x)\n", debugstr_w(pszUrl), pszPath, pcchPath, dwReserved);
3291
3292     if (!pszUrl || !pszPath || !pcchPath || !*pcchPath)
3293         return E_INVALIDARG;
3294
3295
3296     if (strncmpW(pszUrl, file_colon, 5))
3297         return E_INVALIDARG;
3298     pszUrl += 5;
3299
3300     while(*pszUrl == '/' || *pszUrl == '\\') {
3301         nslashes++;
3302         pszUrl++;
3303     }
3304
3305     if(isalphaW(*pszUrl) && (pszUrl[1] == ':' || pszUrl[1] == '|') && (pszUrl[2] == '/' || pszUrl[2] == '\\'))
3306         nslashes = 0;
3307
3308     switch(nslashes) {
3309     case 2:
3310         pszUrl -= 2;
3311         break;
3312     case 0:
3313         break;
3314     default:
3315         pszUrl -= 1;
3316         break;
3317     }
3318
3319     hr = UrlUnescapeW((LPWSTR)pszUrl, pszPath, pcchPath, 0);
3320     if(hr != S_OK) return hr;
3321
3322     for(ptr = pszPath; *ptr; ptr++)
3323         if(*ptr == '/') *ptr = '\\';
3324
3325     while(*pszPath == '\\')
3326         pszPath++;
3327
3328     if(isalphaW(*pszPath) && pszPath[1] == '|' && pszPath[2] == '\\') /* c|\ -> c:\ */
3329         pszPath[1] = ':';
3330
3331     if(nslashes == 2 && (ptr = strchrW(pszPath, '\\'))) { /* \\host\c:\ -> \\hostc:\ */
3332         ptr++;
3333         if(isalphaW(*ptr) && (ptr[1] == ':' || ptr[1] == '|') && ptr[2] == '\\') {
3334             memmove(ptr - 1, ptr, (strlenW(ptr) + 1) * sizeof(WCHAR));
3335             (*pcchPath)--;
3336         }
3337     }
3338
3339     TRACE("Returning %s\n",debugstr_w(pszPath));
3340
3341     return hr;
3342 }
3343
3344 /*************************************************************************
3345  * PathRelativePathToA   [SHLWAPI.@]
3346  *
3347  * Create a relative path from one path to another.
3348  *
3349  * PARAMS
3350  *  lpszPath   [O] Destination for relative path
3351  *  lpszFrom   [I] Source path
3352  *  dwAttrFrom [I] File attribute of source path
3353  *  lpszTo     [I] Destination path
3354  *  dwAttrTo   [I] File attributes of destination path
3355  *
3356  * RETURNS
3357  *  TRUE  If a relative path can be formed. lpszPath contains the new path
3358  *  FALSE If the paths are not relative or any parameters are invalid
3359  *
3360  * NOTES
3361  *  lpszTo should be at least MAX_PATH in length.
3362  *
3363  *  Calling this function with relative paths for lpszFrom or lpszTo may
3364  *  give erroneous results.
3365  *
3366  *  The Win32 version of this function contains a bug where the lpszTo string
3367  *  may be referenced 1 byte beyond the end of the string. As a result random
3368  *  garbage may be written to the output path, depending on what lies beyond
3369  *  the last byte of the string. This bug occurs because of the behaviour of
3370  *  PathCommonPrefix() (see notes for that function), and no workaround seems
3371  *  possible with Win32.
3372  *
3373  *  This bug has been fixed here, so for example the relative path from "\\"
3374  *  to "\\" is correctly determined as "." in this implementation.
3375  */
3376 BOOL WINAPI PathRelativePathToA(LPSTR lpszPath, LPCSTR lpszFrom, DWORD dwAttrFrom,
3377                                 LPCSTR lpszTo, DWORD dwAttrTo)
3378 {
3379   BOOL bRet = FALSE;
3380
3381   TRACE("(%p,%s,0x%08x,%s,0x%08x)\n", lpszPath, debugstr_a(lpszFrom),
3382         dwAttrFrom, debugstr_a(lpszTo), dwAttrTo);
3383
3384   if(lpszPath && lpszFrom && lpszTo)
3385   {
3386     WCHAR szPath[MAX_PATH];
3387     WCHAR szFrom[MAX_PATH];
3388     WCHAR szTo[MAX_PATH];
3389     MultiByteToWideChar(CP_ACP,0,lpszFrom,-1,szFrom,MAX_PATH);
3390     MultiByteToWideChar(CP_ACP,0,lpszTo,-1,szTo,MAX_PATH);
3391     bRet = PathRelativePathToW(szPath,szFrom,dwAttrFrom,szTo,dwAttrTo);
3392     WideCharToMultiByte(CP_ACP,0,szPath,-1,lpszPath,MAX_PATH,0,0);
3393   }
3394   return bRet;
3395 }
3396
3397 /*************************************************************************
3398  * PathRelativePathToW   [SHLWAPI.@]
3399  *
3400  * See PathRelativePathToA.
3401  */
3402 BOOL WINAPI PathRelativePathToW(LPWSTR lpszPath, LPCWSTR lpszFrom, DWORD dwAttrFrom,
3403                                 LPCWSTR lpszTo, DWORD dwAttrTo)
3404 {
3405   static const WCHAR szPrevDirSlash[] = { '.', '.', '\\', '\0' };
3406   static const WCHAR szPrevDir[] = { '.', '.', '\0' };
3407   WCHAR szFrom[MAX_PATH];
3408   WCHAR szTo[MAX_PATH];
3409   DWORD dwLen;
3410
3411   TRACE("(%p,%s,0x%08x,%s,0x%08x)\n", lpszPath, debugstr_w(lpszFrom),
3412         dwAttrFrom, debugstr_w(lpszTo), dwAttrTo);
3413
3414   if(!lpszPath || !lpszFrom || !lpszTo)
3415     return FALSE;
3416
3417   *lpszPath = '\0';
3418   lstrcpynW(szFrom, lpszFrom, MAX_PATH);
3419   lstrcpynW(szTo, lpszTo, MAX_PATH);
3420
3421   if(!(dwAttrFrom & FILE_ATTRIBUTE_DIRECTORY))
3422     PathRemoveFileSpecW(szFrom);
3423   if(!(dwAttrFrom & FILE_ATTRIBUTE_DIRECTORY))
3424     PathRemoveFileSpecW(szTo);
3425
3426   /* Paths can only be relative if they have a common root */
3427   if(!(dwLen = PathCommonPrefixW(szFrom, szTo, 0)))
3428     return FALSE;
3429
3430   /* Strip off lpszFrom components to the root, by adding "..\" */
3431   lpszFrom = szFrom + dwLen;
3432   if (!*lpszFrom)
3433   {
3434     lpszPath[0] = '.';
3435     lpszPath[1] = '\0';
3436   }
3437   if (*lpszFrom == '\\')
3438     lpszFrom++;
3439
3440   while (*lpszFrom)
3441   {
3442     lpszFrom = PathFindNextComponentW(lpszFrom);
3443     strcatW(lpszPath, *lpszFrom ? szPrevDirSlash : szPrevDir);
3444   }
3445
3446   /* From the root add the components of lpszTo */
3447   lpszTo += dwLen;
3448   /* We check lpszTo[-1] to avoid skipping end of string. See the notes for
3449    * this function.
3450    */
3451   if (*lpszTo && lpszTo[-1])
3452   {
3453     if (*lpszTo != '\\')
3454       lpszTo--;
3455     dwLen = strlenW(lpszPath);
3456     if (dwLen + strlenW(lpszTo) >= MAX_PATH)
3457     {
3458       *lpszPath = '\0';
3459       return FALSE;
3460     }
3461     strcpyW(lpszPath + dwLen, lpszTo);
3462   }
3463   return TRUE;
3464 }
3465
3466 /*************************************************************************
3467  * PathUnmakeSystemFolderA   [SHLWAPI.@]
3468  *
3469  * Remove the system folder attributes from a path.
3470  *
3471  * PARAMS
3472  *  lpszPath [I] The path to remove attributes from
3473  *
3474  * RETURNS
3475  *  Success: TRUE.
3476  *  Failure: FALSE, if lpszPath is NULL, empty, not a directory, or calling
3477  *           SetFileAttributesA() fails.
3478  */
3479 BOOL WINAPI PathUnmakeSystemFolderA(LPCSTR lpszPath)
3480 {
3481   DWORD dwAttr;
3482
3483   TRACE("(%s)\n", debugstr_a(lpszPath));
3484
3485   if (!lpszPath || !*lpszPath || (dwAttr = GetFileAttributesA(lpszPath)) == INVALID_FILE_ATTRIBUTES ||
3486       !(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
3487     return FALSE;
3488
3489   dwAttr &= ~(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM);
3490   return SetFileAttributesA(lpszPath, dwAttr);
3491 }
3492
3493 /*************************************************************************
3494  * PathUnmakeSystemFolderW   [SHLWAPI.@]
3495  *
3496  * See PathUnmakeSystemFolderA.
3497  */
3498 BOOL WINAPI PathUnmakeSystemFolderW(LPCWSTR lpszPath)
3499 {
3500   DWORD dwAttr;
3501
3502   TRACE("(%s)\n", debugstr_w(lpszPath));
3503
3504   if (!lpszPath || !*lpszPath || (dwAttr = GetFileAttributesW(lpszPath)) == INVALID_FILE_ATTRIBUTES ||
3505     !(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
3506     return FALSE;
3507
3508   dwAttr &= ~(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM);
3509   return SetFileAttributesW(lpszPath, dwAttr);
3510 }
3511
3512
3513 /*************************************************************************
3514  * PathSetDlgItemPathA   [SHLWAPI.@]
3515  *
3516  * Set the text of a dialog item to a path, shrinking the path to fit
3517  * if it is too big for the item.
3518  *
3519  * PARAMS
3520  *  hDlg     [I] Dialog handle
3521  *  id       [I] ID of item in the dialog
3522  *  lpszPath [I] Path to set as the items text
3523  *
3524  * RETURNS
3525  *  Nothing.
3526  *
3527  * NOTES
3528  *  If lpszPath is NULL, a blank string ("") is set (i.e. The previous
3529  *  window text is erased).
3530  */
3531 VOID WINAPI PathSetDlgItemPathA(HWND hDlg, int id, LPCSTR lpszPath)
3532 {
3533   WCHAR szPath[MAX_PATH];
3534
3535   TRACE("(%p,%8x,%s)\n",hDlg, id, debugstr_a(lpszPath));
3536
3537   if (lpszPath)
3538     MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
3539   else
3540     szPath[0] = '\0';
3541   PathSetDlgItemPathW(hDlg, id, szPath);
3542 }
3543
3544 /*************************************************************************
3545  * PathSetDlgItemPathW   [SHLWAPI.@]
3546  *
3547  * See PathSetDlgItemPathA.
3548  */
3549 VOID WINAPI PathSetDlgItemPathW(HWND hDlg, int id, LPCWSTR lpszPath)
3550 {
3551   WCHAR path[MAX_PATH + 1];
3552   HWND hwItem;
3553   RECT rect;
3554   HDC hdc;
3555   HGDIOBJ hPrevObj;
3556
3557   TRACE("(%p,%8x,%s)\n",hDlg, id, debugstr_w(lpszPath));
3558
3559   if (!(hwItem = GetDlgItem(hDlg, id)))
3560     return;
3561
3562   if (lpszPath)
3563     lstrcpynW(path, lpszPath, sizeof(path) / sizeof(WCHAR));
3564   else
3565     path[0] = '\0';
3566
3567   GetClientRect(hwItem, &rect);
3568   hdc = GetDC(hDlg);
3569   hPrevObj = SelectObject(hdc, (HGDIOBJ)SendMessageW(hwItem,WM_GETFONT,0,0));
3570
3571   if (hPrevObj)
3572   {
3573     PathCompactPathW(hdc, path, rect.right);
3574     SelectObject(hdc, hPrevObj);
3575   }
3576
3577   ReleaseDC(hDlg, hdc);
3578   SetWindowTextW(hwItem, path);
3579 }
3580
3581 /*************************************************************************
3582  * PathIsNetworkPathA [SHLWAPI.@]
3583  *
3584  * Determine if the given path is a network path.
3585  *
3586  * PARAMS
3587  *  lpszPath [I] Path to check
3588  *
3589  * RETURNS
3590  *  TRUE  If lpszPath is a UNC share or mapped network drive, or
3591  *  FALSE If lpszPath is a local drive or cannot be determined
3592  */
3593 BOOL WINAPI PathIsNetworkPathA(LPCSTR lpszPath)
3594 {
3595   int dwDriveNum;
3596
3597   TRACE("(%s)\n",debugstr_a(lpszPath));
3598
3599   if (!lpszPath)
3600     return FALSE;
3601   if (*lpszPath == '\\' && lpszPath[1] == '\\')
3602     return TRUE;
3603   dwDriveNum = PathGetDriveNumberA(lpszPath);
3604   if (dwDriveNum == -1)
3605     return FALSE;
3606   GET_FUNC(pIsNetDrive, shell32, (LPCSTR)66, FALSE); /* ord 66 = shell32.IsNetDrive */
3607   return pIsNetDrive(dwDriveNum);
3608 }
3609
3610 /*************************************************************************
3611  * PathIsNetworkPathW [SHLWAPI.@]
3612  *
3613  * See PathIsNetworkPathA.
3614  */
3615 BOOL WINAPI PathIsNetworkPathW(LPCWSTR lpszPath)
3616 {
3617   int dwDriveNum;
3618
3619   TRACE("(%s)\n", debugstr_w(lpszPath));
3620
3621   if (!lpszPath)
3622     return FALSE;
3623   if (*lpszPath == '\\' && lpszPath[1] == '\\')
3624     return TRUE;
3625   dwDriveNum = PathGetDriveNumberW(lpszPath);
3626   if (dwDriveNum == -1)
3627     return FALSE;
3628   GET_FUNC(pIsNetDrive, shell32, (LPCSTR)66, FALSE); /* ord 66 = shell32.IsNetDrive */
3629   return pIsNetDrive(dwDriveNum);
3630 }
3631
3632 /*************************************************************************
3633  * PathIsLFNFileSpecA [SHLWAPI.@]
3634  *
3635  * Determine if the given path is a long file name
3636  *
3637  * PARAMS
3638  *  lpszPath [I] Path to check
3639  *
3640  * RETURNS
3641  *  TRUE  If path is a long file name,
3642  *  FALSE If path is a valid DOS short file name
3643  */
3644 BOOL WINAPI PathIsLFNFileSpecA(LPCSTR lpszPath)
3645 {
3646   DWORD dwNameLen = 0, dwExtLen = 0;
3647
3648   TRACE("(%s)\n",debugstr_a(lpszPath));
3649
3650   if (!lpszPath)
3651     return FALSE;
3652
3653   while (*lpszPath)
3654   {
3655     if (*lpszPath == ' ')
3656       return TRUE; /* DOS names cannot have spaces */
3657     if (*lpszPath == '.')
3658     {
3659       if (dwExtLen)
3660         return TRUE; /* DOS names have only one dot */
3661       dwExtLen = 1;
3662     }
3663     else if (dwExtLen)
3664     {
3665       dwExtLen++;
3666       if (dwExtLen > 4)
3667         return TRUE; /* DOS extensions are <= 3 chars*/
3668     }
3669     else
3670     {
3671       dwNameLen++;
3672       if (dwNameLen > 8)
3673         return TRUE; /* DOS names are <= 8 chars */
3674     }
3675     lpszPath += IsDBCSLeadByte(*lpszPath) ? 2 : 1;
3676   }
3677   return FALSE; /* Valid DOS path */
3678 }
3679
3680 /*************************************************************************
3681  * PathIsLFNFileSpecW [SHLWAPI.@]
3682  *
3683  * See PathIsLFNFileSpecA.
3684  */
3685 BOOL WINAPI PathIsLFNFileSpecW(LPCWSTR lpszPath)
3686 {
3687   DWORD dwNameLen = 0, dwExtLen = 0;
3688
3689   TRACE("(%s)\n",debugstr_w(lpszPath));
3690
3691   if (!lpszPath)
3692     return FALSE;
3693
3694   while (*lpszPath)
3695   {
3696     if (*lpszPath == ' ')
3697       return TRUE; /* DOS names cannot have spaces */
3698     if (*lpszPath == '.')
3699     {
3700       if (dwExtLen)
3701         return TRUE; /* DOS names have only one dot */
3702       dwExtLen = 1;
3703     }
3704     else if (dwExtLen)
3705     {
3706       dwExtLen++;
3707       if (dwExtLen > 4)
3708         return TRUE; /* DOS extensions are <= 3 chars*/
3709     }
3710     else
3711     {
3712       dwNameLen++;
3713       if (dwNameLen > 8)
3714         return TRUE; /* DOS names are <= 8 chars */
3715     }
3716     lpszPath++;
3717   }
3718   return FALSE; /* Valid DOS path */
3719 }
3720
3721 /*************************************************************************
3722  * PathIsDirectoryEmptyA [SHLWAPI.@]
3723  *
3724  * Determine if a given directory is empty.
3725  *
3726  * PARAMS
3727  *  lpszPath [I] Directory to check
3728  *
3729  * RETURNS
3730  *  TRUE  If the directory exists and contains no files,
3731  *  FALSE Otherwise
3732  */
3733 BOOL WINAPI PathIsDirectoryEmptyA(LPCSTR lpszPath)
3734 {
3735   BOOL bRet = FALSE;
3736
3737   TRACE("(%s)\n",debugstr_a(lpszPath));
3738
3739   if (lpszPath)
3740   {
3741     WCHAR szPath[MAX_PATH];
3742     MultiByteToWideChar(CP_ACP,0,lpszPath,-1,szPath,MAX_PATH);
3743     bRet = PathIsDirectoryEmptyW(szPath);
3744   }
3745   return bRet;
3746 }
3747
3748 /*************************************************************************
3749  * PathIsDirectoryEmptyW [SHLWAPI.@]
3750  *
3751  * See PathIsDirectoryEmptyA.
3752  */
3753 BOOL WINAPI PathIsDirectoryEmptyW(LPCWSTR lpszPath)
3754 {
3755   static const WCHAR szAllFiles[] = { '*', '.', '*', '\0' };
3756   WCHAR szSearch[MAX_PATH];
3757   DWORD dwLen;
3758   HANDLE hfind;
3759   BOOL retVal = FALSE;
3760   WIN32_FIND_DATAW find_data;
3761
3762   TRACE("(%s)\n",debugstr_w(lpszPath));
3763
3764   if (!lpszPath || !PathIsDirectoryW(lpszPath))
3765       return FALSE;
3766
3767   lstrcpynW(szSearch, lpszPath, MAX_PATH);
3768   PathAddBackslashW(szSearch);
3769   dwLen = strlenW(szSearch);
3770   if (dwLen > MAX_PATH - 4)
3771     return FALSE;
3772
3773   strcpyW(szSearch + dwLen, szAllFiles);
3774   hfind = FindFirstFileW(szSearch, &find_data);
3775
3776   if (hfind != INVALID_HANDLE_VALUE &&
3777       find_data.cFileName[0] == '.' &&
3778       find_data.cFileName[1] == '.')
3779   {
3780     /* The only directory entry should be the parent */
3781     if (!FindNextFileW(hfind, &find_data))
3782       retVal = TRUE;
3783     FindClose(hfind);
3784   }
3785   return retVal;
3786 }
3787
3788
3789 /*************************************************************************
3790  * PathFindSuffixArrayA [SHLWAPI.@]
3791  *
3792  * Find a suffix string in an array of suffix strings
3793  *
3794  * PARAMS
3795  *  lpszSuffix [I] Suffix string to search for
3796  *  lppszArray [I] Array of suffix strings to search
3797  *  dwCount    [I] Number of elements in lppszArray
3798  *
3799  * RETURNS
3800  *  Success: The index of the position of lpszSuffix in lppszArray
3801  *  Failure: 0, if any parameters are invalid or lpszSuffix is not found
3802  *
3803  * NOTES
3804  *  The search is case sensitive.
3805  *  The match is made against the end of the suffix string, so for example:
3806  *  lpszSuffix="fooBAR" matches "BAR", but lpszSuffix="fooBARfoo" does not.
3807  */
3808 LPCSTR WINAPI PathFindSuffixArrayA(LPCSTR lpszSuffix, LPCSTR *lppszArray, int dwCount)
3809 {
3810   size_t dwLen;
3811   int dwRet = 0;
3812
3813   TRACE("(%s,%p,%d)\n",debugstr_a(lpszSuffix), lppszArray, dwCount);
3814
3815   if (lpszSuffix && lppszArray && dwCount > 0)
3816   {
3817     dwLen = strlen(lpszSuffix);
3818
3819     while (dwRet < dwCount)
3820     {
3821       size_t dwCompareLen = strlen(*lppszArray);
3822       if (dwCompareLen < dwLen)
3823       {
3824         if (!strcmp(lpszSuffix + dwLen - dwCompareLen, *lppszArray))
3825           return *lppszArray; /* Found */
3826       }
3827       dwRet++;
3828       lppszArray++;
3829     }
3830   }
3831   return NULL;
3832 }
3833
3834 /*************************************************************************
3835  * PathFindSuffixArrayW [SHLWAPI.@]
3836  *
3837  * See PathFindSuffixArrayA.
3838  */
3839 LPCWSTR WINAPI PathFindSuffixArrayW(LPCWSTR lpszSuffix, LPCWSTR *lppszArray, int dwCount)
3840 {
3841   size_t dwLen;
3842   int dwRet = 0;
3843
3844   TRACE("(%s,%p,%d)\n",debugstr_w(lpszSuffix), lppszArray, dwCount);
3845
3846   if (lpszSuffix && lppszArray && dwCount > 0)
3847   {
3848     dwLen = strlenW(lpszSuffix);
3849
3850     while (dwRet < dwCount)
3851     {
3852       size_t dwCompareLen = strlenW(*lppszArray);
3853       if (dwCompareLen < dwLen)
3854       {
3855         if (!strcmpW(lpszSuffix + dwLen - dwCompareLen, *lppszArray))
3856           return *lppszArray; /* Found */
3857       }
3858       dwRet++;
3859       lppszArray++;
3860     }
3861   }
3862   return NULL;
3863 }
3864
3865 /*************************************************************************
3866  * PathUndecorateA [SHLWAPI.@]
3867  *
3868  * Undecorate a file path
3869  *
3870  * PARAMS
3871  *  lpszPath [I/O] Path to remove any decoration from
3872  *
3873  * RETURNS
3874  *  Nothing
3875  *
3876  * NOTES
3877  *  A decorations form is "path[n].ext" where "n" is an optional decimal number.
3878  */
3879 VOID WINAPI PathUndecorateA(LPSTR lpszPath)
3880 {
3881   TRACE("(%s)\n",debugstr_a(lpszPath));
3882
3883   if (lpszPath)
3884   {
3885     LPSTR lpszExt = PathFindExtensionA(lpszPath);
3886     if (lpszExt > lpszPath && lpszExt[-1] == ']')
3887     {
3888       LPSTR lpszSkip = lpszExt - 2;
3889       if (*lpszSkip == '[')
3890         lpszSkip++;  /* [] (no number) */
3891       else
3892         while (lpszSkip > lpszPath && isdigit(lpszSkip[-1]))
3893           lpszSkip--;
3894       if (lpszSkip > lpszPath && lpszSkip[-1] == '[' && lpszSkip[-2] != '\\')
3895       {
3896         /* remove the [n] */
3897         lpszSkip--;
3898         while (*lpszExt)
3899           *lpszSkip++ = *lpszExt++;
3900         *lpszSkip = '\0';
3901       }
3902     }
3903   }
3904 }
3905
3906 /*************************************************************************
3907  * PathUndecorateW [SHLWAPI.@]
3908  *
3909  * See PathUndecorateA.
3910  */
3911 VOID WINAPI PathUndecorateW(LPWSTR lpszPath)
3912 {
3913   TRACE("(%s)\n",debugstr_w(lpszPath));
3914
3915   if (lpszPath)
3916   {
3917     LPWSTR lpszExt = PathFindExtensionW(lpszPath);
3918     if (lpszExt > lpszPath && lpszExt[-1] == ']')
3919     {
3920       LPWSTR lpszSkip = lpszExt - 2;
3921       if (*lpszSkip == '[')
3922         lpszSkip++; /* [] (no number) */
3923       else
3924         while (lpszSkip > lpszPath && isdigitW(lpszSkip[-1]))
3925           lpszSkip--;
3926       if (lpszSkip > lpszPath && lpszSkip[-1] == '[' && lpszSkip[-2] != '\\')
3927       {
3928         /* remove the [n] */
3929         lpszSkip--;
3930         while (*lpszExt)
3931           *lpszSkip++ = *lpszExt++;
3932         *lpszSkip = '\0';
3933       }
3934     }
3935   }
3936 }
3937
3938 /*************************************************************************
3939  * PathUnExpandEnvStringsA [SHLWAPI.@]
3940  *
3941  * Substitute folder names in a path with their corresponding environment
3942  * strings.
3943  *
3944  * PARAMS
3945  *  pszPath  [I] Buffer containing the path to unexpand.
3946  *  pszBuf   [O] Buffer to receive the unexpanded path.
3947  *  cchBuf   [I] Size of pszBuf in characters.
3948  *
3949  * RETURNS
3950  *  Success: TRUE
3951  *  Failure: FALSE
3952  */
3953 BOOL WINAPI PathUnExpandEnvStringsA(LPCSTR pszPath, LPSTR pszBuf, UINT cchBuf)
3954 {
3955     FIXME("(%s,%s,0x%08x)\n", debugstr_a(pszPath), debugstr_a(pszBuf), cchBuf);
3956     return FALSE;
3957 }
3958
3959 /*************************************************************************
3960  * PathUnExpandEnvStringsW [SHLWAPI.@]
3961  *
3962  * Unicode version of PathUnExpandEnvStringsA.
3963  */
3964 BOOL WINAPI PathUnExpandEnvStringsW(LPCWSTR pszPath, LPWSTR pszBuf, UINT cchBuf)
3965 {
3966     FIXME("(%s,%s,0x%08x)\n", debugstr_w(pszPath), debugstr_w(pszBuf), cchBuf);
3967     return FALSE;
3968 }
3969
3970 /*************************************************************************
3971  * @     [SHLWAPI.440]
3972  *
3973  * Find localised or default web content in "%WINDOWS%\web\".
3974  *
3975  * PARAMS
3976  *  lpszFile  [I] File name containing content to look for
3977  *  lpszPath  [O] Buffer to contain the full path to the file
3978  *  dwPathLen [I] Length of lpszPath
3979  *
3980  * RETURNS
3981  *  Success: S_OK. lpszPath contains the full path to the content.
3982  *  Failure: E_FAIL. The content does not exist or lpszPath is too short.
3983  */
3984 HRESULT WINAPI SHGetWebFolderFilePathA(LPCSTR lpszFile, LPSTR lpszPath, DWORD dwPathLen)
3985 {
3986   WCHAR szFile[MAX_PATH], szPath[MAX_PATH];
3987   HRESULT hRet;
3988
3989   TRACE("(%s,%p,%d)\n", lpszFile, lpszPath, dwPathLen);
3990
3991   MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, szFile, MAX_PATH);
3992   szPath[0] = '\0';
3993   hRet = SHGetWebFolderFilePathW(szFile, szPath, dwPathLen);
3994   WideCharToMultiByte(CP_ACP, 0, szPath, -1, lpszPath, dwPathLen, 0, 0);
3995   return hRet;
3996 }
3997
3998 /*************************************************************************
3999  * @     [SHLWAPI.441]
4000  *
4001  * Unicode version of SHGetWebFolderFilePathA.
4002  */
4003 HRESULT WINAPI SHGetWebFolderFilePathW(LPCWSTR lpszFile, LPWSTR lpszPath, DWORD dwPathLen)
4004 {
4005   static const WCHAR szWeb[] = {'\\','W','e','b','\\','\0'};
4006   static const WCHAR szWebMui[] = {'m','u','i','\\','%','0','4','x','\\','\0'};
4007 #define szWebLen (sizeof(szWeb)/sizeof(WCHAR))
4008 #define szWebMuiLen ((sizeof(szWebMui)+1)/sizeof(WCHAR))
4009   DWORD dwLen, dwFileLen;
4010   LANGID lidSystem, lidUser;
4011
4012   TRACE("(%s,%p,%d)\n", debugstr_w(lpszFile), lpszPath, dwPathLen);
4013
4014   /* Get base directory for web content */
4015   dwLen = GetSystemWindowsDirectoryW(lpszPath, dwPathLen);
4016   if (dwLen > 0 && lpszPath[dwLen-1] == '\\')
4017     dwLen--;
4018
4019   dwFileLen = strlenW(lpszFile);
4020
4021   if (dwLen + dwFileLen + szWebLen >= dwPathLen)
4022     return E_FAIL; /* lpszPath too short */
4023
4024   strcpyW(lpszPath+dwLen, szWeb);
4025   dwLen += szWebLen;
4026   dwPathLen = dwPathLen - dwLen; /* Remaining space */
4027
4028   lidSystem = GetSystemDefaultUILanguage();
4029   lidUser = GetUserDefaultUILanguage();
4030
4031   if (lidSystem != lidUser)
4032   {
4033     if (dwFileLen + szWebMuiLen < dwPathLen)
4034     {
4035       /* Use localised content in the users UI language if present */
4036       wsprintfW(lpszPath + dwLen, szWebMui, lidUser);
4037       strcpyW(lpszPath + dwLen + szWebMuiLen, lpszFile);
4038       if (PathFileExistsW(lpszPath))
4039         return S_OK;
4040     }
4041   }
4042
4043   /* Fall back to OS default installed content */
4044   strcpyW(lpszPath + dwLen, lpszFile);
4045   if (PathFileExistsW(lpszPath))
4046     return S_OK;
4047   return E_FAIL;
4048 }
4049
4050 #define PATH_CHAR_CLASS_LETTER      0x00000001
4051 #define PATH_CHAR_CLASS_ASTERIX     0x00000002
4052 #define PATH_CHAR_CLASS_DOT         0x00000004
4053 #define PATH_CHAR_CLASS_BACKSLASH   0x00000008
4054 #define PATH_CHAR_CLASS_COLON       0x00000010
4055 #define PATH_CHAR_CLASS_SEMICOLON   0x00000020
4056 #define PATH_CHAR_CLASS_COMMA       0x00000040
4057 #define PATH_CHAR_CLASS_SPACE       0x00000080
4058 #define PATH_CHAR_CLASS_OTHER_VALID 0x00000100
4059 #define PATH_CHAR_CLASS_DOUBLEQUOTE 0x00000200
4060
4061 #define PATH_CHAR_CLASS_INVALID     0x00000000
4062 #define PATH_CHAR_CLASS_ANY         0xffffffff
4063
4064 static const DWORD SHELL_charclass[] =
4065 {
4066     /* 0x00 */  PATH_CHAR_CLASS_INVALID,      /* 0x01 */  PATH_CHAR_CLASS_INVALID,
4067     /* 0x02 */  PATH_CHAR_CLASS_INVALID,      /* 0x03 */  PATH_CHAR_CLASS_INVALID,
4068     /* 0x04 */  PATH_CHAR_CLASS_INVALID,      /* 0x05 */  PATH_CHAR_CLASS_INVALID,
4069     /* 0x06 */  PATH_CHAR_CLASS_INVALID,      /* 0x07 */  PATH_CHAR_CLASS_INVALID,
4070     /* 0x08 */  PATH_CHAR_CLASS_INVALID,      /* 0x09 */  PATH_CHAR_CLASS_INVALID,
4071     /* 0x0a */  PATH_CHAR_CLASS_INVALID,      /* 0x0b */  PATH_CHAR_CLASS_INVALID,
4072     /* 0x0c */  PATH_CHAR_CLASS_INVALID,      /* 0x0d */  PATH_CHAR_CLASS_INVALID,
4073     /* 0x0e */  PATH_CHAR_CLASS_INVALID,      /* 0x0f */  PATH_CHAR_CLASS_INVALID,
4074     /* 0x10 */  PATH_CHAR_CLASS_INVALID,      /* 0x11 */  PATH_CHAR_CLASS_INVALID,
4075     /* 0x12 */  PATH_CHAR_CLASS_INVALID,      /* 0x13 */  PATH_CHAR_CLASS_INVALID,
4076     /* 0x14 */  PATH_CHAR_CLASS_INVALID,      /* 0x15 */  PATH_CHAR_CLASS_INVALID,
4077     /* 0x16 */  PATH_CHAR_CLASS_INVALID,      /* 0x17 */  PATH_CHAR_CLASS_INVALID,
4078     /* 0x18 */  PATH_CHAR_CLASS_INVALID,      /* 0x19 */  PATH_CHAR_CLASS_INVALID,
4079     /* 0x1a */  PATH_CHAR_CLASS_INVALID,      /* 0x1b */  PATH_CHAR_CLASS_INVALID,
4080     /* 0x1c */  PATH_CHAR_CLASS_INVALID,      /* 0x1d */  PATH_CHAR_CLASS_INVALID,
4081     /* 0x1e */  PATH_CHAR_CLASS_INVALID,      /* 0x1f */  PATH_CHAR_CLASS_INVALID,
4082     /* ' '  */  PATH_CHAR_CLASS_SPACE,        /* '!'  */  PATH_CHAR_CLASS_OTHER_VALID,
4083     /* '"'  */  PATH_CHAR_CLASS_DOUBLEQUOTE,  /* '#'  */  PATH_CHAR_CLASS_OTHER_VALID,
4084     /* '$'  */  PATH_CHAR_CLASS_OTHER_VALID,  /* '%'  */  PATH_CHAR_CLASS_OTHER_VALID,
4085     /* '&'  */  PATH_CHAR_CLASS_OTHER_VALID,  /* '\'' */  PATH_CHAR_CLASS_OTHER_VALID,
4086     /* '('  */  PATH_CHAR_CLASS_OTHER_VALID,  /* ')'  */  PATH_CHAR_CLASS_OTHER_VALID,
4087     /* '*'  */  PATH_CHAR_CLASS_ASTERIX,      /* '+'  */  PATH_CHAR_CLASS_OTHER_VALID,
4088     /* ','  */  PATH_CHAR_CLASS_COMMA,        /* '-'  */  PATH_CHAR_CLASS_OTHER_VALID,
4089     /* '.'  */  PATH_CHAR_CLASS_DOT,          /* '/'  */  PATH_CHAR_CLASS_INVALID,
4090     /* '0'  */  PATH_CHAR_CLASS_OTHER_VALID,  /* '1'  */  PATH_CHAR_CLASS_OTHER_VALID,
4091     /* '2'  */  PATH_CHAR_CLASS_OTHER_VALID,  /* '3'  */  PATH_CHAR_CLASS_OTHER_VALID,
4092     /* '4'  */  PATH_CHAR_CLASS_OTHER_VALID,  /* '5'  */  PATH_CHAR_CLASS_OTHER_VALID,
4093     /* '6'  */  PATH_CHAR_CLASS_OTHER_VALID,  /* '7'  */  PATH_CHAR_CLASS_OTHER_VALID,
4094     /* '8'  */  PATH_CHAR_CLASS_OTHER_VALID,  /* '9'  */  PATH_CHAR_CLASS_OTHER_VALID,
4095     /* ':'  */  PATH_CHAR_CLASS_COLON,        /* ';'  */  PATH_CHAR_CLASS_SEMICOLON,
4096     /* '<'  */  PATH_CHAR_CLASS_INVALID,      /* '='  */  PATH_CHAR_CLASS_OTHER_VALID,
4097     /* '>'  */  PATH_CHAR_CLASS_INVALID,      /* '?'  */  PATH_CHAR_CLASS_LETTER,
4098     /* '@'  */  PATH_CHAR_CLASS_OTHER_VALID,  /* 'A'  */  PATH_CHAR_CLASS_ANY,
4099     /* 'B'  */  PATH_CHAR_CLASS_ANY,          /* 'C'  */  PATH_CHAR_CLASS_ANY,
4100     /* 'D'  */  PATH_CHAR_CLASS_ANY,          /* 'E'  */  PATH_CHAR_CLASS_ANY,
4101     /* 'F'  */  PATH_CHAR_CLASS_ANY,          /* 'G'  */  PATH_CHAR_CLASS_ANY,
4102     /* 'H'  */  PATH_CHAR_CLASS_ANY,          /* 'I'  */  PATH_CHAR_CLASS_ANY,
4103     /* 'J'  */  PATH_CHAR_CLASS_ANY,          /* 'K'  */  PATH_CHAR_CLASS_ANY,
4104     /* 'L'  */  PATH_CHAR_CLASS_ANY,          /* 'M'  */  PATH_CHAR_CLASS_ANY,
4105     /* 'N'  */  PATH_CHAR_CLASS_ANY,          /* 'O'  */  PATH_CHAR_CLASS_ANY,
4106     /* 'P'  */  PATH_CHAR_CLASS_ANY,          /* 'Q'  */  PATH_CHAR_CLASS_ANY,
4107     /* 'R'  */  PATH_CHAR_CLASS_ANY,          /* 'S'  */  PATH_CHAR_CLASS_ANY,
4108     /* 'T'  */  PATH_CHAR_CLASS_ANY,          /* 'U'  */  PATH_CHAR_CLASS_ANY,
4109     /* 'V'  */  PATH_CHAR_CLASS_ANY,          /* 'W'  */  PATH_CHAR_CLASS_ANY,
4110     /* 'X'  */  PATH_CHAR_CLASS_ANY,          /* 'Y'  */  PATH_CHAR_CLASS_ANY,
4111     /* 'Z'  */  PATH_CHAR_CLASS_ANY,          /* '['  */  PATH_CHAR_CLASS_OTHER_VALID,
4112     /* '\\' */  PATH_CHAR_CLASS_BACKSLASH,    /* ']'  */  PATH_CHAR_CLASS_OTHER_VALID,
4113     /* '^'  */  PATH_CHAR_CLASS_OTHER_VALID,  /* '_'  */  PATH_CHAR_CLASS_OTHER_VALID,
4114     /* '`'  */  PATH_CHAR_CLASS_OTHER_VALID,  /* 'a'  */  PATH_CHAR_CLASS_ANY,
4115     /* 'b'  */  PATH_CHAR_CLASS_ANY,          /* 'c'  */  PATH_CHAR_CLASS_ANY,
4116     /* 'd'  */  PATH_CHAR_CLASS_ANY,          /* 'e'  */  PATH_CHAR_CLASS_ANY,
4117     /* 'f'  */  PATH_CHAR_CLASS_ANY,          /* 'g'  */  PATH_CHAR_CLASS_ANY,
4118     /* 'h'  */  PATH_CHAR_CLASS_ANY,          /* 'i'  */  PATH_CHAR_CLASS_ANY,
4119     /* 'j'  */  PATH_CHAR_CLASS_ANY,          /* 'k'  */  PATH_CHAR_CLASS_ANY,
4120     /* 'l'  */  PATH_CHAR_CLASS_ANY,          /* 'm'  */  PATH_CHAR_CLASS_ANY,
4121     /* 'n'  */  PATH_CHAR_CLASS_ANY,          /* 'o'  */  PATH_CHAR_CLASS_ANY,
4122     /* 'p'  */  PATH_CHAR_CLASS_ANY,          /* 'q'  */  PATH_CHAR_CLASS_ANY,
4123     /* 'r'  */  PATH_CHAR_CLASS_ANY,          /* 's'  */  PATH_CHAR_CLASS_ANY,
4124     /* 't'  */  PATH_CHAR_CLASS_ANY,          /* 'u'  */  PATH_CHAR_CLASS_ANY,
4125     /* 'v'  */  PATH_CHAR_CLASS_ANY,          /* 'w'  */  PATH_CHAR_CLASS_ANY,
4126     /* 'x'  */  PATH_CHAR_CLASS_ANY,          /* 'y'  */  PATH_CHAR_CLASS_ANY,
4127     /* 'z'  */  PATH_CHAR_CLASS_ANY,          /* '{'  */  PATH_CHAR_CLASS_OTHER_VALID,
4128     /* '|'  */  PATH_CHAR_CLASS_INVALID,      /* '}'  */  PATH_CHAR_CLASS_OTHER_VALID,
4129     /* '~'  */  PATH_CHAR_CLASS_OTHER_VALID
4130 };
4131
4132 /*************************************************************************
4133  * @     [SHLWAPI.455]
4134  *
4135  * Check if an ASCII char is of a certain class
4136  */
4137 BOOL WINAPI PathIsValidCharA( char c, DWORD class )
4138 {
4139     if ((unsigned)c > 0x7e)
4140         return class & PATH_CHAR_CLASS_OTHER_VALID;
4141
4142     return class & SHELL_charclass[(unsigned)c];
4143 }
4144
4145 /*************************************************************************
4146  * @     [SHLWAPI.456]
4147  *
4148  * Check if a Unicode char is of a certain class
4149  */
4150 BOOL WINAPI PathIsValidCharW( WCHAR c, DWORD class )
4151 {
4152     if (c > 0x7e)
4153         return class & PATH_CHAR_CLASS_OTHER_VALID;
4154
4155     return class & SHELL_charclass[c];
4156 }