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