dlls/shlwapi/path.c

   1 /*
   2  * Path Functions
   3  */
   4
   5 #include <ctype.h>
   6 #include <string.h>
   7
   8 #include "winerror.h"
   9 #include "wine/unicode.h"
  10 #include "wine/undocshell.h"
  11 #include "shlwapi.h"
  12 #include "debugtools.h"
  13
  14 DEFAULT_DEBUG_CHANNEL(shell);
  15
  16 #define isSlash(x) ((x)=='\\' || (x)=='/')
  17 /*
  18         ########## Combining and Constructing paths ##########
  19 */
  20
  21 /*************************************************************************
  22  * PathAppendA          [SHLWAPI.@]
  23  *
  24  * NOTES
  25  *  concat path lpszPath2 onto lpszPath1
  26  *
  27  * FIXME
  28  *  the resulting path is also canonicalized
  29  */
  30 BOOL WINAPI PathAppendA(
  31         LPSTR lpszPath1,
  32         LPCSTR lpszPath2)
  33 {
  34         TRACE("%s %s\n",lpszPath1, lpszPath2);
  35         while (lpszPath2[0]=='\\') lpszPath2++;
  36         PathCombineA(lpszPath1,lpszPath1,lpszPath2);
  37         return TRUE;
  38 }
  39
  40 /*************************************************************************
  41  * PathAppendW          [SHLWAPI.@]
  42  */
  43 BOOL WINAPI PathAppendW(
  44         LPWSTR lpszPath1,
  45         LPCWSTR lpszPath2)
  46 {
  47         TRACE("%s %s\n",debugstr_w(lpszPath1), debugstr_w(lpszPath2));
  48         while (lpszPath2[0]=='\\') lpszPath2++;
  49         PathCombineW(lpszPath1,lpszPath1,lpszPath2);
  50         return TRUE;
  51 }
  52
  53 /*************************************************************************
  54  * PathCombineA         [SHLWAPI.@]
  55  *
  56  * NOTES
  57  *  if lpszFile='.' skip it
  58  *  szDest can be equal to lpszFile. Thats why we use sTemp
  59  *
  60  * FIXME
  61  *  the resulting path is also canonicalized
  62  */
  63 LPSTR WINAPI PathCombineA(
  64         LPSTR szDest,
  65         LPCSTR lpszDir,
  66         LPCSTR lpszFile)
  67 {
  68         char sTemp[MAX_PATH];
  69         TRACE("%p %p->%s %p->%s\n",szDest, lpszDir, lpszDir, lpszFile, lpszFile);
  70
  71
  72         if (!lpszFile || !lpszFile[0] || (lpszFile[0]=='.' && !lpszFile[1]) )
  73         {
  74           strcpy(szDest,lpszDir);
  75           return szDest;
  76         }
  77
  78         /*  if lpszFile is a complete path don't care about lpszDir */
  79         if (PathGetDriveNumberA(lpszFile) != -1)
  80         {
  81           strcpy(szDest,lpszFile);
  82         }
  83         else if (lpszFile[0] == '\\' )
  84         {
  85           strcpy(sTemp,lpszDir);
  86           PathStripToRootA(sTemp);
  87           strcat(sTemp,lpszFile);
  88           strcpy(szDest,sTemp);
  89         }
  90         else
  91         {
  92           strcpy(sTemp,lpszDir);
  93           PathAddBackslashA(sTemp);
  94           strcat(sTemp,lpszFile);
  95           strcpy(szDest,sTemp);
  96         }
  97         return szDest;
  98 }
  99
 100 /*************************************************************************
 101  * PathCombineW          [SHLWAPI.@]
 102  */
 103 LPWSTR WINAPI PathCombineW(
 104         LPWSTR szDest,
 105         LPCWSTR lpszDir,
 106         LPCWSTR lpszFile)
 107 {
 108         WCHAR sTemp[MAX_PATH];
 109         TRACE("%p %p->%s %p->%s\n",szDest, lpszDir, debugstr_w(lpszDir),
 110                          lpszFile, debugstr_w(lpszFile));
 111
 112
 113         if (!lpszFile || !lpszFile[0] || (lpszFile[0]==(WCHAR)'.' && !lpszFile[1]) )
 114         {
 115           strcpyW(szDest,lpszDir);
 116           return szDest;
 117         }
 118
 119         /*  if lpszFile is a complete path don't care about lpszDir */
 120         if (PathGetDriveNumberW(lpszFile) != -1)
 121         {
 122             strcpyW(szDest,lpszFile);
 123         }
 124         else if (lpszFile[0] == (WCHAR)'\\' )
 125         {
 126           strcpyW(sTemp,lpszDir);
 127           PathStripToRootW(sTemp);
 128           strcatW(sTemp,lpszFile);
 129           strcpyW(szDest,sTemp);
 130         }
 131         else
 132         {
 133           strcpyW(sTemp,lpszDir);
 134           PathAddBackslashW(sTemp);
 135           strcatW(sTemp,lpszFile);
 136           strcpyW(szDest,sTemp);
 137         }
 138         return szDest;
 139 }
 140
 141 /*************************************************************************
 142  * PathAddBackslashA    [SHLWAPI.@]
 143  *
 144  * NOTES
 145  *     append \ if there is none
 146  */
 147 LPSTR WINAPI PathAddBackslashA(LPSTR lpszPath)
 148 {
 149         int len;
 150         TRACE("%p->%s\n",lpszPath,lpszPath);
 151
 152         len = strlen(lpszPath);
 153         if (len && lpszPath[len-1]!='\\')
 154         {
 155           lpszPath[len]  = '\\';
 156           lpszPath[len+1]= 0x00;
 157           return lpszPath+len+1;
 158         }
 159         return lpszPath+len;
 160 }
 161
 162 /*************************************************************************
 163  * PathAddBackslashW    [SHLWAPI.@]
 164  */
 165 LPWSTR WINAPI PathAddBackslashW(LPWSTR lpszPath)
 166 {
 167         int len;
 168         TRACE("%p->%s\n",lpszPath,debugstr_w(lpszPath));
 169
 170         len = strlenW(lpszPath);
 171         if (len && lpszPath[len-1]!=(WCHAR)'\\')
 172         {
 173           lpszPath[len]  = (WCHAR)'\\';
 174           lpszPath[len+1]= 0x00;
 175           return lpszPath+len+1;
 176         }
 177         return lpszPath+len;
 178 }
 179
 180 /*************************************************************************
 181  * PathBuildRootA               [SHLWAPI.@]
 182  */
 183 LPSTR WINAPI PathBuildRootA(LPSTR lpszPath, int drive)
 184 {
 185         TRACE("%p %i\n",lpszPath, drive);
 186
 187         strcpy(lpszPath,"A:\\");
 188         lpszPath[0]+=drive;
 189         return lpszPath;
 190 }
 191
 192 /*************************************************************************
 193  * PathBuildRootW               [SHLWAPI.@]
 194  */
 195 LPWSTR WINAPI PathBuildRootW(LPWSTR lpszPath, int drive)
 196 {
 197         TRACE("%p %i\n",debugstr_w(lpszPath), drive);
 198
 199         lstrcpyAtoW(lpszPath,"A:\\");
 200         lpszPath[0]+=drive;
 201         return lpszPath;
 202 }
 203
 204 /*
 205         Extracting Component Parts
 206 */
 207
 208 /*************************************************************************
 209  * PathFindFileNameA    [SHLWAPI.@]
 210  */
 211 LPSTR WINAPI PathFindFileNameA(LPCSTR lpszPath)
 212 {
 213         LPCSTR lastSlash = lpszPath;
 214
 215         TRACE("%s\n",lpszPath);
 216         while (*lpszPath)
 217         {
 218           if ( isSlash(lpszPath[0]) && lpszPath[1])
 219               lastSlash = lpszPath+1;
 220           lpszPath = CharNextA(lpszPath);
 221         }
 222         return (LPSTR)lastSlash;
 223
 224 }
 225
 226 /*************************************************************************
 227  * PathFindFileNameW    [SHLWAPI.@]
 228  */
 229 LPWSTR WINAPI PathFindFileNameW(LPCWSTR lpszPath)
 230 {
 231         LPCWSTR wslash;
 232         wslash = lpszPath;
 233
 234         TRACE("%s\n",debugstr_w(wslash));
 235         while (lpszPath[0])
 236         {
 237           if (((lpszPath[0]=='\\') || (lpszPath[0]==':')) && lpszPath[1] && lpszPath[1]!='\\')
 238             wslash = lpszPath+1;
 239           lpszPath = CharNextW(lpszPath);
 240         }
 241         return (LPWSTR)wslash;
 242 }
 243
 244 /*************************************************************************
 245  * PathFindExtensionA   [SHLWAPI.@]
 246  *
 247  * NOTES
 248  *     returns pointer to last . in last lpszPath component or at \0.
 249  */
 250
 251 LPSTR WINAPI PathFindExtensionA(LPCSTR lpszPath)
 252 {
 253         LPCSTR   lastpoint = NULL;
 254
 255         TRACE("%p %s\n",lpszPath,lpszPath);
 256
 257         while (*lpszPath)
 258         {
 259           if (*lpszPath=='\\'||*lpszPath==' ')
 260             lastpoint=NULL;
 261           if (*lpszPath=='.')
 262             lastpoint=lpszPath;
 263           lpszPath = CharNextA(lpszPath);
 264         }
 265         return (LPSTR)(lastpoint?lastpoint:lpszPath);
 266 }
 267
 268 /*************************************************************************
 269  * PathFindExtensionW   [SHLWAPI.@]
 270  */
 271 LPWSTR WINAPI PathFindExtensionW(LPCWSTR lpszPath)
 272 {
 273         LPCWSTR   lastpoint = NULL;
 274
 275         TRACE("(%p %s)\n",lpszPath,debugstr_w(lpszPath));
 276
 277         while (*lpszPath)
 278         {
 279           if (*lpszPath==(WCHAR)'\\'||*lpszPath==(WCHAR)' ')
 280             lastpoint=NULL;
 281           if (*lpszPath==(WCHAR)'.')
 282             lastpoint=lpszPath;
 283           lpszPath = CharNextW(lpszPath);
 284         }
 285         return (LPWSTR)(lastpoint?lastpoint:lpszPath);
 286 }
 287
 288 /*************************************************************************
 289  * PathGetExtensionA            [internal]
 290  *
 291  * NOTES
 292  *  exported by ordinal
 293  *  return value points to the first char after the dot
 294  */
 295 LPSTR WINAPI PathGetExtensionA(LPCSTR lpszPath)
 296 {
 297         TRACE("(%s)\n",lpszPath);
 298
 299         lpszPath = PathFindExtensionA(lpszPath);
 300         return (LPSTR)(*lpszPath?(lpszPath+1):lpszPath);
 301 }
 302
 303 /*************************************************************************
 304  * PathGetExtensionW            [internal]
 305  */
 306 LPWSTR WINAPI PathGetExtensionW(LPCWSTR lpszPath)
 307 {
 308         TRACE("(%s)\n",debugstr_w(lpszPath));
 309
 310         lpszPath = PathFindExtensionW(lpszPath);
 311         return (LPWSTR)(*lpszPath?(lpszPath+1):lpszPath);
 312 }
 313
 314 /*************************************************************************
 315  * PathGetArgsA         [SHLWAPI.@]
 316  *
 317  * NOTES
 318  *     look for next arg in string. handle "quoted" strings
 319  *     returns pointer to argument *AFTER* the space. Or to the \0.
 320  *
 321  * FIXME
 322  *     quoting by '\'
 323  */
 324 LPSTR WINAPI PathGetArgsA(LPCSTR lpszPath)
 325 {
 326         BOOL    qflag = FALSE;
 327
 328         TRACE("%s\n",lpszPath);
 329
 330         while (*lpszPath)
 331         {
 332           if ((*lpszPath==' ') && !qflag)
 333             return (LPSTR)lpszPath+1;
 334           if (*lpszPath=='"')
 335             qflag=!qflag;
 336           lpszPath = CharNextA(lpszPath);
 337         }
 338         return (LPSTR)lpszPath;
 339 }
 340
 341 /*************************************************************************
 342  * PathGetArgsW         [SHLWAPI.@]
 343  */
 344 LPWSTR WINAPI PathGetArgsW(LPCWSTR lpszPath)
 345 {
 346         BOOL    qflag = FALSE;
 347
 348         TRACE("%s\n",debugstr_w(lpszPath));
 349
 350         while (*lpszPath)
 351         {
 352           if ((*lpszPath==' ') && !qflag)
 353             return (LPWSTR)lpszPath+1;
 354           if (*lpszPath=='"')
 355             qflag=!qflag;
 356           lpszPath = CharNextW(lpszPath);
 357         }
 358         return (LPWSTR)lpszPath;
 359 }
 360
 361 /*************************************************************************
 362  * PathGetDriveNumberA  [SHLWAPI.@]
 363  */
 364 int WINAPI PathGetDriveNumberA(LPCSTR lpszPath)
 365 {
 366         int chr = tolower(lpszPath[0]);
 367
 368         TRACE ("%s\n",debugstr_a(lpszPath));
 369
 370         if (!lpszPath || lpszPath[1]!=':' || chr < 'a' || chr > 'z') return -1;
 371         return tolower(lpszPath[0]) - 'a' ;
 372 }
 373
 374 /*************************************************************************
 375  * PathGetDriveNumberW  [SHLWAPI.@]
 376  */
 377 int WINAPI PathGetDriveNumberW(LPCWSTR lpszPath)
 378 {
 379         int chr = tolowerW(lpszPath[0]);
 380
 381         TRACE ("%s\n",debugstr_w(lpszPath));
 382
 383         if (!lpszPath || lpszPath[1]!=':' || chr < 'a' || chr > 'z') return -1;
 384         return tolowerW(lpszPath[0]) - 'a' ;
 385 }
 386
 387 /*************************************************************************
 388  * PathRemoveFileSpecA  [SHLWAPI.@]
 389  *
 390  * NOTES
 391  *     truncates passed argument to a valid path
 392  *     returns if the string was modified or not.
 393  *     "\foo\xx\foo"-> "\foo\xx"
 394  *     "\" -> "\"
 395  *     "a:\foo" -> "a:\"
 396  */
 397 BOOL WINAPI PathRemoveFileSpecA(LPSTR lpszPath)
 398 {
 399         LPSTR cutplace = lpszPath;
 400         BOOL ret = FALSE;
 401
 402         TRACE("%s\n",lpszPath);
 403
 404         if(lpszPath)
 405         {
 406           while (*lpszPath == '\\') cutplace = ++lpszPath;
 407
 408           while (*lpszPath)
 409           {
 410             if(lpszPath[0] == '\\') cutplace = lpszPath;
 411
 412             if(lpszPath[0] == ':')
 413             {
 414               cutplace = lpszPath + 1;
 415               if (lpszPath[1] == '\\') cutplace++;
 416               lpszPath++;
 417             }
 418             lpszPath = CharNextA(lpszPath);
 419             if (!lpszPath) break;
 420           }
 421
 422           ret = (*cutplace!='\0');
 423           *cutplace = '\0';
 424         }
 425         return ret;
 426 }
 427
 428 /*************************************************************************
 429  * PathRemoveFileSpecW  [SHLWAPI.@]
 430  */
 431 BOOL WINAPI PathRemoveFileSpecW(LPWSTR lpszPath)
 432 {
 433         LPWSTR cutplace = lpszPath;
 434         BOOL ret = FALSE;
 435
 436         TRACE("%s\n",debugstr_w(lpszPath));
 437
 438         if(lpszPath)
 439         {
 440           while (*lpszPath == '\\') cutplace = ++lpszPath;
 441
 442           while (*lpszPath)
 443           {
 444             if(lpszPath[0] == '\\') cutplace = lpszPath;
 445
 446             if(lpszPath[0] == ':')
 447             {
 448               cutplace = lpszPath + 1;
 449               if (lpszPath[1] == '\\') cutplace++;
 450               lpszPath++;
 451             }
 452             lpszPath = CharNextW(lpszPath);
 453             if (!lpszPath) break;
 454           }
 455
 456           ret = (*cutplace!='\0');
 457           *cutplace = '\0';
 458         }
 459         return ret;
 460 }
 461
 462 /*************************************************************************
 463  * PathStripPathA       [SHELLWAPI.@]
 464  *
 465  * NOTES
 466  *  removes the path from the beginning of a filename
 467  */
 468 void WINAPI PathStripPathA(LPSTR lpszPath)
 469 {
 470         LPSTR lpszFileName = PathFindFileNameA(lpszPath);
 471
 472         TRACE("%s\n", lpszPath);
 473
 474         if(lpszFileName)
 475           RtlMoveMemory(lpszPath, lpszFileName, strlen(lpszFileName)+1);
 476 }
 477
 478 /*************************************************************************
 479  * PathStripPathW       [SHELLWAPI.@]
 480  */
 481 void WINAPI PathStripPathW(LPWSTR lpszPath)
 482 {
 483         LPWSTR lpszFileName = PathFindFileNameW(lpszPath);
 484
 485         TRACE("%s\n", debugstr_w(lpszPath));
 486         if(lpszFileName)
 487           RtlMoveMemory(lpszPath, lpszFileName, (lstrlenW(lpszFileName)+1)*sizeof(WCHAR));
 488 }
 489
 490 /*************************************************************************
 491  * PathStripToRootA     [SHLWAPI.@]
 492  */
 493 BOOL WINAPI PathStripToRootA(LPSTR lpszPath)
 494 {
 495         TRACE("%s\n", lpszPath);
 496
 497         if (!lpszPath) return FALSE;
 498         while(!PathIsRootA(lpszPath))
 499           if (!PathRemoveFileSpecA(lpszPath)) return FALSE;
 500         return TRUE;
 501 }
 502
 503 /*************************************************************************
 504  * PathStripToRootW     [SHLWAPI.@]
 505  */
 506 BOOL WINAPI PathStripToRootW(LPWSTR lpszPath)
 507 {
 508         TRACE("%s\n", debugstr_w(lpszPath));
 509
 510         if (!lpszPath) return FALSE;
 511         while(!PathIsRootW(lpszPath))
 512           if (!PathRemoveFileSpecW(lpszPath)) return FALSE;
 513         return TRUE;
 514 }
 515
 516 /*************************************************************************
 517  * PathRemoveArgsA      [SHLWAPI.@]
 518  *
 519  */
 520 void WINAPI PathRemoveArgsA(LPSTR lpszPath)
 521 {
 522         TRACE("%s\n",lpszPath);
 523
 524         if(lpszPath)
 525         {
 526           LPSTR lpszArgs = PathGetArgsA(lpszPath);
 527           if (!*lpszArgs)
 528           {
 529             LPSTR lpszLastChar = CharPrevA(lpszPath, lpszArgs);
 530             if(*lpszLastChar==' ') *lpszLastChar = '\0';
 531           }
 532         }
 533 }
 534
 535 /*************************************************************************
 536  * PathRemoveArgsW      [SHLWAPI.@]
 537  */
 538 void WINAPI PathRemoveArgsW(LPWSTR lpszPath)
 539 {
 540         TRACE("%s\n", debugstr_w(lpszPath));
 541
 542         if(lpszPath)
 543         {
 544           LPWSTR lpszArgs = PathGetArgsW(lpszPath);
 545           if (!*lpszArgs)
 546           {
 547             LPWSTR lpszLastChar = CharPrevW(lpszPath, lpszArgs);
 548             if(*lpszLastChar==' ') *lpszLastChar = '\0';
 549           }
 550         }
 551 }
 552
 553 /*************************************************************************
 554  * PathRemoveExtensionA         [SHLWAPI.@]
 555  */
 556 void WINAPI PathRemoveExtensionA(LPSTR lpszPath)
 557 {
 558         LPSTR lpszExtension = PathFindExtensionA(lpszPath);
 559
 560         TRACE("%s\n", lpszPath);
 561
 562         if (lpszExtension) *lpszExtension='\0';
 563 }
 564
 565 /*************************************************************************
 566  * PathRemoveExtensionW         [SHLWAPI.@]
 567  */
 568 void WINAPI PathRemoveExtensionW(LPWSTR lpszPath)
 569 {
 570         LPWSTR lpszExtension = PathFindExtensionW(lpszPath);
 571
 572         TRACE("%s\n", debugstr_w(lpszPath));
 573
 574         if (lpszExtension) *lpszExtension='\0';
 575 }
 576
 577 /*************************************************************************
 578  * PathRemoveBackslashA [SHLWAPI.@]
 579  *
 580  * If the path ends in a backslash it is replaced by a NULL
 581  * and the address of the NULL is returned
 582  * Otherwise
 583  * the address of the last character is returned.
 584  *
 585  * FIXME
 586  *  "c:\": keep backslash
 587  */
 588 LPSTR WINAPI PathRemoveBackslashA( LPSTR lpszPath )
 589 {
 590         int len;
 591         LPSTR szTemp = NULL;
 592
 593         if(lpszPath)
 594         {
 595           len = strlen(lpszPath);
 596           szTemp = CharPrevA(lpszPath, lpszPath+len);
 597           if (! PathIsRootA(lpszPath))
 598           {
 599             if (*szTemp == '\\') *szTemp = '\0';
 600           }
 601         }
 602         return szTemp;
 603 }
 604
 605 /*************************************************************************
 606  * PathRemoveBackslashW [SHLWAPI.@]
 607  */
 608 LPWSTR WINAPI PathRemoveBackslashW( LPWSTR lpszPath )
 609 {
 610         int len;
 611         LPWSTR szTemp = NULL;
 612
 613         if(lpszPath)
 614         {
 615           len = lstrlenW(lpszPath);
 616           szTemp = CharPrevW(lpszPath, lpszPath+len);
 617           if (! PathIsRootW(lpszPath))
 618           {
 619             if (*szTemp == '\\') *szTemp = '\0';
 620           }
 621         }
 622         return szTemp;
 623 }
 624
 625
 626 /*
 627         Path Manipulations
 628 */
 629
 630 /*************************************************************************
 631  * PathRemoveBlanksA [SHLWAPI.@]
 632  *
 633  * NOTES
 634  *     remove spaces from beginning and end of passed string
 635  */
 636 void WINAPI PathRemoveBlanksA(LPSTR str)
 637 {
 638         LPSTR x = str;
 639
 640         TRACE("%s\n",str);
 641
 642         if(str)
 643         {
 644           while (*x==' ') x = CharNextA(x);
 645           if (x!=str) strcpy(str,x);
 646           x=str+strlen(str)-1;
 647           while (*x==' ') x = CharPrevA(str, x);
 648           if (*x==' ') *x='\0';
 649         }
 650 }
 651
 652 /*************************************************************************
 653  * PathRemoveBlanksW [SHLWAPI.@]
 654  */
 655 void WINAPI PathRemoveBlanksW(LPWSTR str)
 656 {
 657         LPWSTR x = str;
 658
 659         TRACE("%s\n",debugstr_w(str));
 660
 661         if(str)
 662         {
 663           while (*x==' ') x = CharNextW(x);
 664           if (x!=str) lstrcpyW(str,x);
 665           x=str+lstrlenW(str)-1;
 666           while (*x==' ') x = CharPrevW(str, x);
 667           if (*x==' ') *x='\0';
 668         }
 669 }
 670
 671 /*************************************************************************
 672  * PathQuoteSpacesA [SHLWAPI.@]
 673  *
 674  */
 675 LPSTR WINAPI PathQuoteSpacesA(LPSTR lpszPath)
 676 {
 677         TRACE("%s\n",lpszPath);
 678
 679         if(StrChrA(lpszPath,' '))
 680         {
 681           int len = strlen(lpszPath);
 682           RtlMoveMemory(lpszPath+1, lpszPath, len);
 683           *(lpszPath++) = '"';
 684           lpszPath += len;
 685           *(lpszPath++) = '"';
 686           *(lpszPath) = '\0';
 687           return --lpszPath;
 688         }
 689         return 0;
 690 }
 691
 692 /*************************************************************************
 693  * PathQuoteSpacesW [SHLWAPI.@]
 694  */
 695 LPWSTR WINAPI PathQuoteSpacesW(LPWSTR lpszPath)
 696 {
 697         TRACE("%s\n",debugstr_w(lpszPath));
 698
 699         if(StrChrW(lpszPath,' '))
 700         {
 701           int len = lstrlenW(lpszPath);
 702           RtlMoveMemory(lpszPath+1, lpszPath, len*sizeof(WCHAR));
 703           *(lpszPath++) = '"';
 704           lpszPath += len;
 705           *(lpszPath++) = '"';
 706           *(lpszPath) = '\0';
 707           return --lpszPath;
 708         }
 709         return 0;
 710 }
 711
 712 /*************************************************************************
 713  * PathUnquoteSpacesA [SHLWAPI.@]
 714  *
 715  * NOTES
 716  *     unquote string (remove ")
 717  */
 718 VOID WINAPI PathUnquoteSpacesA(LPSTR str)
 719 {
 720         DWORD len = lstrlenA(str);
 721
 722         TRACE("%s\n",str);
 723
 724         if (*str!='"')
 725           return;
 726         if (str[len-1]!='"')
 727           return;
 728         str[len-1]='\0';
 729         lstrcpyA(str,str+1);
 730         return;
 731 }
 732
 733 /*************************************************************************
 734  * PathUnquoteSpacesW [SHLWAPI.@]
 735  */
 736 VOID WINAPI PathUnquoteSpacesW(LPWSTR str)
 737 {
 738         DWORD len = strlenW(str);
 739
 740         TRACE("%s\n",debugstr_w(str));
 741
 742         if (*str!='"')
 743           return;
 744         if (str[len-1]!='"')
 745           return;
 746         str[len-1]='\0';
 747         strcpyW(str,str+1);
 748         return;
 749 }
 750
 751 /*************************************************************************
 752  * PathParseIconLocationA       [SHLWAPI.@]
 753  */
 754 int WINAPI PathParseIconLocationA(LPSTR lpszPath)
 755 {
 756         LPSTR lpstrComma = strchr(lpszPath, ',');
 757
 758         FIXME("%s stub\n", debugstr_a(lpszPath));
 759
 760         if (lpstrComma && lpstrComma[1])
 761         {
 762           lpstrComma[0]='\0';
 763 /*        return atoi(&lpstrComma[1]);  FIXME */
 764         }
 765
 766         PathUnquoteSpacesA(lpszPath);
 767         return 0;
 768 }
 769
 770 /*************************************************************************
 771  * PathParseIconLocationW       [SHLWAPI.@]
 772  */
 773 int WINAPI PathParseIconLocationW(LPWSTR lpszPath)
 774 {
 775         LPWSTR lpstrComma = strchrW(lpszPath, ',');
 776
 777         FIXME("%s stub\n", debugstr_w(lpszPath));
 778
 779         if (lpstrComma && lpstrComma[1])
 780         {
 781           lpstrComma[0]='\0';
 782 /*        return _wtoi(&lpstrComma[1]); FIXME */
 783         }
 784         PathUnquoteSpacesW(lpszPath);
 785         return 0;
 786 }
 787
 788 /*
 789         ########## cleaning and resolving paths ##########
 790  */
 791
 792 /*************************************************************************
 793  * PathFindOnPathA      [SHLWAPI.@]
 794  */
 795 BOOL WINAPI PathFindOnPathA(LPSTR sFile, LPCSTR sOtherDirs)
 796 {
 797         FIXME("%s %s\n",sFile, sOtherDirs);
 798         return FALSE;
 799 }
 800
 801 /*************************************************************************
 802  * PathFindOnPathW      [SHLWAPI.@]
 803  */
 804 BOOL WINAPI PathFindOnPathW(LPWSTR sFile, LPCWSTR sOtherDirs)
 805 {
 806         FIXME("%s %s\n",debugstr_w(sFile), debugstr_w(sOtherDirs));
 807         return FALSE;
 808 }
 809
 810 /*************************************************************************
 811  * PathCleanupSpecA     [SHLWAPI.@]
 812  */
 813 DWORD WINAPI PathCleanupSpecA(LPSTR x, LPSTR y)
 814 {
 815         FIXME("(%p %s, %p %s) stub\n",x,debugstr_a(x),y,debugstr_a(y));
 816         return TRUE;
 817 }
 818
 819 /*************************************************************************
 820  * PathCleanupSpecW     [SHLWAPI.@]
 821  */
 822 DWORD WINAPI PathCleanupSpecW(LPWSTR x, LPWSTR y)
 823 {
 824         FIXME("(%p %s, %p %s) stub\n",x,debugstr_w(x),y,debugstr_w(y));
 825         return TRUE;
 826 }
 827
 828 /*************************************************************************
 829  *      PathCompactPathExA   [SHLWAPI.@]
 830  */
 831 BOOL WINAPI PathCompactPathExA(
 832         LPSTR pszOut,
 833         LPCSTR pszSrc,
 834         UINT cchMax,
 835         DWORD dwFlags)
 836 {
 837         FIXME("%p %s 0x%08x 0x%08lx\n", pszOut, pszSrc, cchMax, dwFlags);
 838         return FALSE;
 839 }
 840
 841 /*************************************************************************
 842  *      PathCompactPathExW   [SHLWAPI.@]
 843  */
 844 BOOL WINAPI PathCompactPathExW(
 845         LPWSTR pszOut,
 846         LPCWSTR pszSrc,
 847         UINT cchMax,
 848         DWORD dwFlags)
 849 {
 850         FIXME("%p %s 0x%08x 0x%08lx\n", pszOut, debugstr_w(pszSrc), cchMax, dwFlags);
 851         return FALSE;
 852 }
 853
 854 /*
 855         ########## Path Testing ##########
 856 */
 857
 858 /*************************************************************************
 859  * PathIsUNCA           [SHLWAPI.@]
 860  *
 861  * NOTES
 862  *     PathIsUNC(char*path);
 863  */
 864 BOOL WINAPI PathIsUNCA(LPCSTR lpszPath)
 865 {
 866         TRACE("%s\n",lpszPath);
 867
 868         return (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'));
 869 }
 870
 871 /*************************************************************************
 872  * PathIsUNCW           [SHLWAPI.@]
 873  */
 874 BOOL WINAPI PathIsUNCW(LPCWSTR lpszPath)
 875 {
 876         TRACE("%s\n",debugstr_w(lpszPath));
 877
 878         return (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'));
 879 }
 880
 881 /*************************************************************************
 882  *  PathIsRelativeA     [SHLWAPI.@]
 883  */
 884 BOOL WINAPI PathIsRelativeA (LPCSTR lpszPath)
 885 {
 886         TRACE("lpszPath=%s\n",lpszPath);
 887
 888         return (lpszPath && (lpszPath[0]!='\\' && lpszPath[1]!=':'));
 889 }
 890
 891 /*************************************************************************
 892  *  PathIsRelativeW     [SHLWAPI.@]
 893  */
 894 BOOL WINAPI PathIsRelativeW (LPCWSTR lpszPath)
 895 {
 896         TRACE("lpszPath=%s\n",debugstr_w(lpszPath));
 897
 898         return (lpszPath && (lpszPath[0]!='\\' && lpszPath[1]!=':'));
 899 }
 900
 901 /*************************************************************************
 902  * PathIsRootA          [SHLWAPI.@]
 903  *
 904  * notes
 905  *  TRUE if the path points to a root directory
 906  */
 907 BOOL WINAPI PathIsRootA(LPCSTR lpszPath)
 908 {
 909         TRACE("%s\n",lpszPath);
 910
 911         /* X:\ */
 912         if (lpszPath[1]==':' && lpszPath[2]=='\\' && lpszPath[3]=='\0')
 913           return TRUE;
 914
 915         /* "\" */
 916         if (lpszPath[0]=='\\' && lpszPath[1]=='\0')
 917           return TRUE;
 918
 919         /* UNC "\\<computer>\<share>" */
 920         if (lpszPath[0]=='\\' && lpszPath[1]=='\\')
 921         {
 922           int foundbackslash = 0;
 923           lpszPath += 2;
 924           while (*lpszPath)
 925           {
 926             if (*lpszPath=='\\') foundbackslash++;
 927             lpszPath = CharNextA(lpszPath);
 928           }
 929           if (foundbackslash <= 1)
 930             return TRUE;
 931         }
 932         return FALSE;
 933 }
 934
 935 /*************************************************************************
 936  * PathIsRootW          [SHLWAPI.@]
 937  */
 938 BOOL WINAPI PathIsRootW(LPCWSTR lpszPath)
 939 {
 940         TRACE("%s\n",debugstr_w(lpszPath));
 941
 942         /* X:\ */
 943         if (lpszPath[1]==':' && lpszPath[2]=='\\' && lpszPath[3]=='\0')
 944           return TRUE;
 945
 946         /* "\" */
 947         if (lpszPath[0]=='\\' && lpszPath[1]=='\0')
 948           return TRUE;
 949
 950         /* UNC "\\<computer>\<share>" */
 951         if (lpszPath[0]=='\\' && lpszPath[1]=='\\')
 952         {
 953           int foundbackslash = 0;
 954           lpszPath += 2;
 955           while (*lpszPath)
 956           {
 957             if (*lpszPath=='\\') foundbackslash++;
 958             lpszPath = CharNextW(lpszPath);
 959           }
 960           if (foundbackslash <= 1)
 961             return TRUE;
 962         }
 963         return FALSE;
 964
 965 }
 966
 967 /*************************************************************************
 968  *  PathIsExeA          [internal]
 969  */
 970 BOOL WINAPI PathIsExeA (LPCSTR lpszPath)
 971 {
 972         LPCSTR lpszExtension = PathGetExtensionA(lpszPath);
 973         int i = 0;
 974         static char * lpszExtensions[6] = {"exe", "com", "pid", "cmd", "bat", NULL };
 975
 976         TRACE("path=%s\n",lpszPath);
 977
 978         for(i=0; lpszExtensions[i]; i++)
 979           if (!strcasecmp(lpszExtension,lpszExtensions[i])) return TRUE;
 980
 981         return FALSE;
 982 }
 983
 984 /*************************************************************************
 985  *  PathIsExeW          [internal]
 986  */
 987 BOOL WINAPI PathIsExeW (LPCWSTR lpszPath)
 988 {
 989         LPCWSTR lpszExtension = PathGetExtensionW(lpszPath);
 990         int i = 0;
 991         static WCHAR lpszExtensions[6][4] =
 992           {{'e','x','e','\0'}, {'c','o','m','\0'}, {'p','i','d','\0'},
 993            {'c','m','d','\0'}, {'b','a','t','\0'}, {'\0'} };
 994
 995         TRACE("path=%s\n",debugstr_w(lpszPath));
 996
 997         for(i=0; lpszExtensions[i]; i++)
 998           if (!strcmpiW(lpszExtension,lpszExtensions[i])) return TRUE;
 999
1000         return FALSE;
1001 }
1002
1003 /*************************************************************************
1004  * PathIsDirectoryA     [SHLWAPI.@]
1005  */
1006 BOOL WINAPI PathIsDirectoryA(LPCSTR lpszPath)
1007 {
1008         DWORD dwAttr;
1009
1010         TRACE("%s\n", debugstr_a(lpszPath));
1011
1012         dwAttr = GetFileAttributesA(lpszPath);
1013         return  (dwAttr != -1) ? dwAttr & FILE_ATTRIBUTE_DIRECTORY : 0;
1014 }
1015
1016 /*************************************************************************
1017  * PathIsDirectoryW     [SHLWAPI.@]
1018  */
1019 BOOL WINAPI PathIsDirectoryW(LPCWSTR lpszPath)
1020 {
1021         DWORD dwAttr;
1022
1023         TRACE("%s\n", debugstr_w(lpszPath));
1024
1025         dwAttr = GetFileAttributesW(lpszPath);
1026         return  (dwAttr != -1) ? dwAttr & FILE_ATTRIBUTE_DIRECTORY : 0;
1027 }
1028
1029 /*************************************************************************
1030  * PathFileExistsA      [SHLWAPI.@]
1031  *
1032  * NOTES
1033  *     file_exists(char *fn);
1034  */
1035 BOOL WINAPI PathFileExistsA(LPCSTR lpszPath)
1036 {
1037         TRACE("%s\n",lpszPath);
1038         return  (GetFileAttributesA(lpszPath)!=-1);
1039 }
1040
1041 /*************************************************************************
1042  * PathFileExistsW      [SHLWAPI.@]
1043  */
1044 BOOL WINAPI PathFileExistsW(LPCWSTR lpszPath)
1045 {
1046         TRACE("%s\n",debugstr_w(lpszPath));
1047         return  (GetFileAttributesW(lpszPath)!=-1);
1048 }
1049
1050 /*************************************************************************
1051  * PathMatchSingleMaskA [internal]
1052  *
1053  * NOTES
1054  *     internal (used by PathMatchSpec)
1055  */
1056 static BOOL PathMatchSingleMaskA(LPCSTR name, LPCSTR mask)
1057 {
1058         while (*name && *mask && *mask!=';')
1059         {
1060           if (*mask=='*')
1061           {
1062             do
1063             {
1064               if (PathMatchSingleMaskA(name,mask+1)) return 1;  /* try substrings */
1065             } while (*name++);
1066             return 0;
1067           }
1068           if (toupper(*mask)!=toupper(*name) && *mask!='?') return 0;
1069           name = CharNextA(name);
1070           mask = CharNextA(mask);
1071         }
1072         if (!*name)
1073         {
1074           while (*mask=='*') mask++;
1075           if (!*mask || *mask==';') return 1;
1076         }
1077         return 0;
1078 }
1079
1080 /*************************************************************************
1081  * PathMatchSingleMaskW [internal]
1082  */
1083 static BOOL PathMatchSingleMaskW(LPCWSTR name, LPCWSTR mask)
1084 {
1085         while (*name && *mask && *mask!=';')
1086         {
1087           if (*mask=='*')
1088           {
1089             do
1090             {
1091               if (PathMatchSingleMaskW(name,mask+1)) return 1;  /* try substrings */
1092             } while (*name++);
1093             return 0;
1094           }
1095           if (toupperW(*mask)!=toupperW(*name) && *mask!='?') return 0;
1096           name = CharNextW(name);
1097           mask = CharNextW(mask);
1098         }
1099         if (!*name)
1100         {
1101           while (*mask=='*') mask++;
1102           if (!*mask || *mask==';') return 1;
1103         }
1104         return 0;
1105 }
1106 /*************************************************************************
1107  * PathMatchSpecA       [SHLWAPI.@]
1108  *
1109  * NOTES
1110  *     used from COMDLG32
1111  */
1112 BOOL WINAPI PathMatchSpecA(LPCSTR name, LPCSTR mask)
1113 {
1114         TRACE("%s %s\n",name,mask);
1115
1116         if (!lstrcmpA( mask, "*.*" )) return 1;   /* we don't require a period */
1117
1118         while (*mask)
1119         {
1120           if (PathMatchSingleMaskA(name,mask)) return 1;    /* helper function */
1121           while (*mask && *mask!=';') mask = CharNextA(mask);
1122           if (*mask==';')
1123           {
1124             mask++;
1125             while (*mask==' ') mask++;      /*  masks may be separated by "; " */
1126           }
1127         }
1128         return 0;
1129 }
1130
1131 /*************************************************************************
1132  * PathMatchSpecW       [SHLWAPI.@]
1133  */
1134 BOOL WINAPI PathMatchSpecW(LPCWSTR name, LPCWSTR mask)
1135 {
1136         WCHAR stemp[4];
1137         TRACE("%s %s\n",debugstr_w(name),debugstr_w(mask));
1138
1139         lstrcpyAtoW(stemp,"*.*");
1140         if (!lstrcmpW( mask, stemp )) return 1;   /* we don't require a period */
1141
1142         while (*mask)
1143         {
1144           if (PathMatchSingleMaskW(name,mask)) return 1;    /* helper function */
1145           while (*mask && *mask!=';') mask = CharNextW(mask);
1146           if (*mask==';')
1147           {
1148             mask++;
1149             while (*mask==' ') mask++;       /* masks may be separated by "; " */
1150           }
1151         }
1152         return 0;
1153 }
1154
1155 /*************************************************************************
1156  * PathIsSameRootA      [SHLWAPI.@]
1157  *
1158  * FIXME
1159  *  what to do with "\path" ??
1160  */
1161 BOOL WINAPI PathIsSameRootA(LPCSTR lpszPath1, LPCSTR lpszPath2)
1162 {
1163         TRACE("%s %s\n", lpszPath1, lpszPath2);
1164
1165         if (PathIsRelativeA(lpszPath1) || PathIsRelativeA(lpszPath2)) return FALSE;
1166
1167         /* usual path */
1168         if ( toupper(lpszPath1[0])==toupper(lpszPath2[0]) &&
1169              lpszPath1[1]==':' && lpszPath2[1]==':' &&
1170              lpszPath1[2]=='\\' && lpszPath2[2]=='\\')
1171           return TRUE;
1172
1173         /* UNC */
1174         if (lpszPath1[0]=='\\' && lpszPath2[0]=='\\' &&
1175             lpszPath1[1]=='\\' && lpszPath2[1]=='\\')
1176         {
1177           int pos=2, bsfound=0;
1178           while (lpszPath1[pos] && lpszPath2[pos] &&
1179                 (lpszPath1[pos] == lpszPath2[pos]))
1180           {
1181             if (lpszPath1[pos]=='\\') bsfound++;
1182             if (bsfound == 2) return TRUE;
1183             pos++; /* fixme: use CharNext*/
1184           }
1185           return (lpszPath1[pos] == lpszPath2[pos]);
1186         }
1187         return FALSE;
1188 }
1189
1190 /*************************************************************************
1191  * PathIsSameRootW      [SHLWAPI.@]
1192  */
1193 BOOL WINAPI PathIsSameRootW(LPCWSTR lpszPath1, LPCWSTR lpszPath2)
1194 {
1195         TRACE("%s %s\n", debugstr_w(lpszPath1), debugstr_w(lpszPath2));
1196
1197         if (PathIsRelativeW(lpszPath1) || PathIsRelativeW(lpszPath2)) return FALSE;
1198
1199         /* usual path */
1200         if ( toupperW(lpszPath1[0])==toupperW(lpszPath2[0]) &&
1201              lpszPath1[1]==':' && lpszPath2[1]==':' &&
1202              lpszPath1[2]=='\\' && lpszPath2[2]=='\\')
1203           return TRUE;
1204
1205         /* UNC */
1206         if (lpszPath1[0]=='\\' && lpszPath2[0]=='\\' &&
1207             lpszPath1[1]=='\\' && lpszPath2[1]=='\\')
1208         {
1209           int pos=2, bsfound=0;
1210           while (lpszPath1[pos] && lpszPath2[pos] &&
1211                 (lpszPath1[pos] == lpszPath2[pos]))
1212           {
1213             if (lpszPath1[pos]=='\\') bsfound++;
1214             if (bsfound == 2) return TRUE;
1215             pos++;/* fixme: use CharNext*/
1216           }
1217           return (lpszPath1[pos] == lpszPath2[pos]);
1218         }
1219         return FALSE;
1220 }
1221
1222 /*************************************************************************
1223  * PathIsURLA
1224  */
1225 BOOL WINAPI PathIsURLA(LPCSTR lpstrPath)
1226 {
1227         LPSTR lpstrRes;
1228         int iSize, i=0;
1229         static LPSTR SupportedProtocol[] =
1230           {"http","https","ftp","gopher","file","mailto",NULL};
1231
1232         if(!lpstrPath) return FALSE;
1233
1234         /* get protocol        */
1235         lpstrRes = strchr(lpstrPath,':');
1236         if(!lpstrRes) return FALSE;
1237         iSize = lpstrRes - lpstrPath;
1238
1239         while(SupportedProtocol[i])
1240         {
1241           if (iSize == strlen(SupportedProtocol[i]))
1242             if(!strncasecmp(lpstrPath, SupportedProtocol[i], iSize))
1243               return TRUE;
1244           i++;
1245         }
1246
1247         return FALSE;
1248 }
1249
1250 /*************************************************************************
1251  * PathIsURLW
1252  */
1253 BOOL WINAPI PathIsURLW(LPCWSTR lpstrPath)
1254 {
1255         LPWSTR lpstrRes;
1256         int iSize, i=0;
1257         static WCHAR SupportedProtocol[7][7] =
1258           {{'h','t','t','p','\0'},{'h','t','t','p','s','\0'},{'f','t','p','\0'},
1259           {'g','o','p','h','e','r','\0'},{'f','i','l','e','\0'},
1260           {'m','a','i','l','t','o','\0'},{0}};
1261
1262         if(!lpstrPath) return FALSE;
1263
1264         /* get protocol        */
1265         lpstrRes = strchrW(lpstrPath,':');
1266         if(!lpstrRes) return FALSE;
1267         iSize = lpstrRes - lpstrPath;
1268
1269         while(SupportedProtocol[i])
1270         {
1271           if (iSize == strlenW(SupportedProtocol[i]))
1272             if(!strncmpiW(lpstrPath, SupportedProtocol[i], iSize))
1273               return TRUE;
1274           i++;
1275         }
1276
1277         return FALSE;
1278 }
1279
1280
1281 /*************************************************************************
1282  *      PathIsContentTypeA   [SHLWAPI.@]
1283  */
1284 BOOL WINAPI PathIsContentTypeA(LPCSTR pszPath, LPCSTR pszContentType)
1285 {
1286         FIXME("%s %s\n", pszPath, pszContentType);
1287         return FALSE;
1288 }
1289
1290 /*************************************************************************
1291  *      PathIsContentTypeW   [SHLWAPI.@]
1292  */
1293 BOOL WINAPI PathIsContentTypeW(LPCWSTR pszPath, LPCWSTR pszContentType)
1294 {
1295         FIXME("%s %s\n", debugstr_w(pszPath), debugstr_w(pszContentType));
1296         return FALSE;
1297 }
1298
1299 /*************************************************************************
1300  *      PathIsFileSpecA   [SHLWAPI.@]
1301  */
1302 BOOL WINAPI PathIsFileSpecA(LPCSTR pszPath)
1303 {
1304         FIXME("%s\n", pszPath);
1305         return FALSE;
1306 }
1307
1308 /*************************************************************************
1309  *      PathIsFileSpecW   [SHLWAPI.@]
1310  */
1311 BOOL WINAPI PathIsFileSpecW(LPCWSTR pszPath)
1312 {
1313         FIXME("%s\n", debugstr_w(pszPath));
1314         return FALSE;
1315 }
1316
1317 /*************************************************************************
1318  *      PathIsPrefixA   [SHLWAPI.@]
1319  */
1320 BOOL WINAPI PathIsPrefixA(LPCSTR pszPrefix, LPCSTR pszPath)
1321 {
1322         FIXME("%s %s\n", pszPrefix, pszPath);
1323         return FALSE;
1324 }
1325
1326 /*************************************************************************
1327  *      PathIsPrefixW   [SHLWAPI.@]
1328  */
1329 BOOL WINAPI PathIsPrefixW(LPCWSTR pszPrefix, LPCWSTR pszPath)
1330 {
1331         FIXME("%s %s\n", debugstr_w(pszPrefix), debugstr_w(pszPath));
1332         return FALSE;
1333 }
1334
1335 /*************************************************************************
1336  *      PathIsSystemFolderA   [SHLWAPI.@]
1337  */
1338 BOOL WINAPI PathIsSystemFolderA(LPCSTR pszPath, DWORD dwAttrb)
1339 {
1340         FIXME("%s 0x%08lx\n", pszPath, dwAttrb);
1341         return FALSE;
1342 }
1343
1344 /*************************************************************************
1345  *      PathIsSystemFolderW   [SHLWAPI.@]
1346  */
1347 BOOL WINAPI PathIsSystemFolderW(LPCWSTR pszPath, DWORD dwAttrb)
1348 {
1349         FIXME("%s 0x%08lx\n", debugstr_w(pszPath), dwAttrb);
1350         return FALSE;
1351 }
1352
1353 /*************************************************************************
1354  *      PathIsUNCServerA   [SHLWAPI.@]
1355  */
1356 BOOL WINAPI PathIsUNCServerA(
1357         LPCSTR pszPath)
1358 {
1359         FIXME("%s\n", pszPath);
1360         return FALSE;
1361 }
1362
1363 /*************************************************************************
1364  *      PathIsUNCServerW   [SHLWAPI.@]
1365  */
1366 BOOL WINAPI PathIsUNCServerW(
1367         LPCWSTR pszPath)
1368 {
1369         FIXME("%s\n", debugstr_w(pszPath));
1370         return FALSE;
1371 }
1372
1373 /*************************************************************************
1374  *      PathIsUNCServerShareA   [SHLWAPI.@]
1375  */
1376 BOOL WINAPI PathIsUNCServerShareA(
1377         LPCSTR pszPath)
1378 {
1379         FIXME("%s\n", pszPath);
1380         return FALSE;
1381 }
1382
1383 /*************************************************************************
1384  *      PathIsUNCServerShareW   [SHLWAPI.@]
1385  */
1386 BOOL WINAPI PathIsUNCServerShareW(
1387         LPCWSTR pszPath)
1388 {
1389         FIXME("%s\n", debugstr_w(pszPath));
1390         return FALSE;
1391 }
1392
1393 /*************************************************************************
1394  * PathCanonicalizeA   [SHLWAPI.@]
1395  *
1396  *  FIXME
1397  *   returnvalue, use CharNext
1398  */
1399
1400 BOOL WINAPI PathCanonicalizeA(LPSTR pszBuf, LPCSTR pszPath)
1401 {
1402         int OffsetMin = 0, OffsetSrc = 0, OffsetDst = 0, LenSrc = strlen(pszPath);
1403         BOOL bModifyed = FALSE;
1404
1405         TRACE("%p %s\n", pszBuf, pszPath);
1406
1407         pszBuf[OffsetDst]='\0';
1408
1409         /* keep the root of the path */
1410         if( LenSrc && (pszPath[OffsetSrc]=='\\'))
1411         {
1412           pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
1413         }
1414         else if ( (LenSrc >= 2) && (pszPath[OffsetSrc+1] == ':'))
1415         {
1416           pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
1417           pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
1418           if (LenSrc && (pszPath[OffsetSrc] == '\\'))
1419           {
1420             pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
1421             if (LenSrc == 1 && pszPath[OffsetSrc]=='.')
1422             {
1423               /* C:\. */
1424               OffsetSrc++; LenSrc--; bModifyed = TRUE;
1425             }
1426             else if (LenSrc == 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='.')
1427             {
1428               /* C:\.. */
1429               OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
1430             }
1431           }
1432         }
1433
1434         /* ".\" at the beginning of the path */
1435         if (LenSrc >= 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='\\')
1436         {
1437           OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
1438         }
1439
1440         while ( LenSrc )
1441         {
1442           if((LenSrc>=3) && (pszPath[OffsetSrc]=='\\') && (pszPath[OffsetSrc+1]=='.') && (pszPath[OffsetSrc+2]=='.'))
1443           {
1444             /* "\.." found, go one deeper */
1445             while((OffsetDst > OffsetMin) && (pszBuf[OffsetDst]!='\\')) OffsetDst--;
1446             OffsetSrc += 3; LenSrc -= 3; bModifyed = TRUE;
1447             if(OffsetDst == OffsetMin && pszPath[OffsetSrc]=='\\') OffsetSrc++;
1448             pszBuf[OffsetDst] = '\0';                   /* important for \..\.. */
1449           }
1450           else if(LenSrc>=2 && pszPath[OffsetSrc]=='\\' && pszPath[OffsetSrc+1]=='.' )
1451           {
1452             /* "\." found, skip it */
1453             OffsetSrc += 2; LenSrc-=2; bModifyed = TRUE;
1454           }
1455           else
1456           {
1457             pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; LenSrc--;
1458           }
1459         }
1460         pszBuf[OffsetDst] = '\0';
1461         TRACE("-- %s %u\n", pszBuf, bModifyed);
1462         return bModifyed;
1463 }
1464
1465
1466 /*************************************************************************
1467  * PathCanonicalizeW   [SHLWAPI.@]
1468  *
1469  *  FIXME
1470  *   returnvalue, use CharNext
1471  */
1472 BOOL WINAPI PathCanonicalizeW(LPWSTR pszBuf, LPCWSTR pszPath)
1473 {
1474         int OffsetMin = 0, OffsetSrc = 0, OffsetDst = 0, LenSrc = lstrlenW(pszPath);
1475         BOOL bModifyed = FALSE;
1476
1477         TRACE("%p %s\n", pszBuf, debugstr_w(pszPath));
1478
1479         pszBuf[OffsetDst]='\0';
1480
1481         /* keep the root of the path */
1482         if( LenSrc && (pszPath[OffsetSrc]=='\\'))
1483         {
1484           pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
1485         }
1486         else if ( (LenSrc >= 2) && (pszPath[OffsetSrc+1] == ':'))
1487         {
1488           pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
1489           pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
1490           if (LenSrc && (pszPath[OffsetSrc] == '\\'))
1491           {
1492             pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
1493             if (LenSrc == 1 && pszPath[OffsetSrc]=='.')
1494             {
1495               /* C:\. */
1496               OffsetSrc++; LenSrc--; bModifyed = TRUE;
1497             }
1498             else if (LenSrc == 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='.')
1499             {
1500               /* C:\.. */
1501               OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
1502             }
1503           }
1504         }
1505
1506         /* ".\" at the beginning of the path */
1507         if (LenSrc >= 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='\\')
1508         {
1509           OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
1510         }
1511
1512         while ( LenSrc )
1513         {
1514           if((LenSrc>=3) && (pszPath[OffsetSrc]=='\\') && (pszPath[OffsetSrc+1]=='.') && (pszPath[OffsetSrc+2]=='.'))
1515           {
1516             /* "\.." found, go one deeper */
1517             while((OffsetDst > OffsetMin) && (pszBuf[OffsetDst]!='\\')) OffsetDst--;
1518             OffsetSrc += 3; LenSrc -= 3; bModifyed = TRUE;
1519             if(OffsetDst == OffsetMin && pszPath[OffsetSrc]=='\\') OffsetSrc++;
1520             pszBuf[OffsetDst] = '\0';                   /* important for \..\.. */
1521           }
1522           else if(LenSrc>=2 && pszPath[OffsetSrc]=='\\' && pszPath[OffsetSrc+1]=='.' )
1523           {
1524             /* "\." found, skip it */
1525             OffsetSrc += 2; LenSrc-=2; bModifyed = TRUE;
1526           }
1527           else
1528           {
1529             pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; LenSrc--;
1530           }
1531         }
1532         pszBuf[OffsetDst] = '\0';
1533         TRACE("-- %s %u\n", debugstr_w(pszBuf), bModifyed);
1534         return bModifyed;
1535 }
1536
1537 /*************************************************************************
1538  * PathFindNextComponentA   [SHLWAPI.@]
1539  *
1540  * NOTES
1541  * special cases:
1542  *      ""              null
1543  *      aa              "" (pointer to traling NULL)
1544  *      aa\             "" (pointer to traling NULL)
1545  *      aa\\            "" (pointer to traling NULL)
1546  *      aa\\bb          bb
1547  *      aa\\\bb         \bb
1548  *      c:\aa\          "aa\"
1549  *      \\aa            aa
1550  *      \\aa\b          aa\b
1551 */
1552 LPSTR WINAPI PathFindNextComponentA(LPCSTR pszPath)
1553 {
1554         LPSTR pos;
1555
1556         TRACE("%s\n", pszPath);
1557
1558         if(!pszPath || !*pszPath) return NULL;
1559         if(!(pos = StrChrA(pszPath, '\\')))
1560           return (LPSTR) pszPath + strlen(pszPath);
1561         pos++;
1562         if(pos[0] == '\\') pos++;
1563         return pos;
1564 }
1565
1566 /*************************************************************************
1567  * PathFindNextComponentW   [SHLWAPI.@]
1568  */
1569 LPWSTR WINAPI PathFindNextComponentW(LPCWSTR pszPath)
1570 {
1571         LPWSTR pos;
1572
1573         TRACE("%s\n", debugstr_w(pszPath));
1574
1575         if(!pszPath || !*pszPath) return NULL;
1576         if (!(pos = StrChrW(pszPath, '\\')))
1577           return (LPWSTR) pszPath + lstrlenW(pszPath);
1578         pos++;
1579         if(pos[0] == '\\') pos++;
1580         return pos;
1581 }
1582
1583 /*************************************************************************
1584  * PathAddExtensionA   [SHLWAPI.@]
1585  *
1586  * NOTES
1587  *  it adds never a dot
1588  */
1589
1590 BOOL WINAPI PathAddExtensionA(
1591         LPSTR  pszPath,
1592         LPCSTR pszExtension)
1593 {
1594         if (*pszPath)
1595         {
1596           if (*(PathFindExtensionA(pszPath))) return FALSE;
1597
1598           if (!pszExtension || *pszExtension=='\0')
1599             strcat(pszPath, "exe");
1600           else
1601             strcat(pszPath, pszExtension);
1602         }
1603
1604         return TRUE;
1605 }
1606
1607 /*************************************************************************
1608  *      PathAddExtensionW   [SHLWAPI.@]
1609  */
1610 BOOL WINAPI PathAddExtensionW(
1611         LPWSTR  pszPath,
1612         LPCWSTR pszExtension)
1613 {
1614         static const WCHAR ext[] = { 'e','x','e',0 };
1615
1616         if (*pszPath)
1617         {
1618           if (*(PathFindExtensionW(pszPath))) return FALSE;
1619
1620           if (!pszExtension || *pszExtension=='\0')
1621             lstrcatW(pszPath, ext);
1622           else
1623             lstrcatW(pszPath, pszExtension);
1624         }
1625         return TRUE;
1626
1627 }
1628
1629 /*************************************************************************
1630  *      PathMakePrettyA   [SHLWAPI.@]
1631  */
1632 BOOL WINAPI PathMakePrettyA(
1633         LPSTR lpPath)
1634 {
1635         FIXME("%s\n", lpPath);
1636         return TRUE;
1637 }
1638
1639 /*************************************************************************
1640  *      PathMakePrettyW   [SHLWAPI.@]
1641  */
1642 BOOL WINAPI PathMakePrettyW(
1643         LPWSTR lpPath)
1644 {
1645         FIXME("%s\n", debugstr_w(lpPath));
1646         return TRUE;
1647
1648 }
1649
1650 /*************************************************************************
1651  *      PathCommonPrefixA   [SHLWAPI.@]
1652  */
1653 int WINAPI PathCommonPrefixA(
1654         LPCSTR pszFile1,
1655         LPCSTR pszFile2,
1656         LPSTR achPath)
1657 {
1658         FIXME("%s %s %p\n", pszFile1, pszFile2, achPath);
1659         return 0;
1660 }
1661
1662 /*************************************************************************
1663  *      PathCommonPrefixW   [SHLWAPI.@]
1664  */
1665 int WINAPI PathCommonPrefixW(
1666         LPCWSTR pszFile1,
1667         LPCWSTR pszFile2,
1668         LPWSTR achPath)
1669 {
1670         FIXME("%s %s %p\n", debugstr_w(pszFile1), debugstr_w(pszFile2),achPath );
1671         return 0;
1672 }
1673
1674 /*************************************************************************
1675  *      PathCompactPathA   [SHLWAPI.@]
1676  */
1677 BOOL WINAPI PathCompactPathA(HDC hDC, LPSTR pszPath, UINT dx)
1678 {
1679         FIXME("0x%08x %s 0x%08x\n", hDC, pszPath, dx);
1680         return FALSE;
1681 }
1682
1683 /*************************************************************************
1684  *      PathCompactPathW   [SHLWAPI.@]
1685  */
1686 BOOL WINAPI PathCompactPathW(HDC hDC, LPWSTR pszPath, UINT dx)
1687 {
1688         FIXME("0x%08x %s 0x%08x\n", hDC, debugstr_w(pszPath), dx);
1689         return FALSE;
1690 }
1691
1692 /*************************************************************************
1693  *      PathGetCharTypeA   [SHLWAPI.@]
1694  */
1695 UINT WINAPI PathGetCharTypeA(UCHAR ch)
1696 {
1697         FIXME("%c\n", ch);
1698         return 0;
1699 }
1700
1701 /*************************************************************************
1702  *      PathGetCharTypeW   [SHLWAPI.@]
1703  */
1704 UINT WINAPI PathGetCharTypeW(WCHAR ch)
1705 {
1706         FIXME("%c\n", ch);
1707         return 0;
1708 }
1709
1710 /*************************************************************************
1711  *      PathMakeSystemFolderA   [SHLWAPI.@]
1712  */
1713 BOOL WINAPI PathMakeSystemFolderA(LPCSTR pszPath)
1714 {
1715         FIXME("%s\n", pszPath);
1716         return FALSE;
1717 }
1718
1719 /*************************************************************************
1720  *      PathMakeSystemFolderW   [SHLWAPI.@]
1721  */
1722 BOOL WINAPI PathMakeSystemFolderW(LPCWSTR pszPath)
1723 {
1724         FIXME("%s\n", debugstr_w(pszPath));
1725         return FALSE;
1726 }
1727
1728 /*************************************************************************
1729  *      PathRenameExtensionA   [SHLWAPI.@]
1730  */
1731 BOOL WINAPI PathRenameExtensionA(LPSTR pszPath, LPCSTR pszExt)
1732 {
1733         FIXME("%s %s\n", pszPath, pszExt);
1734         return FALSE;
1735 }
1736
1737 /*************************************************************************
1738  *      PathRenameExtensionW   [SHLWAPI.@]
1739  */
1740 BOOL WINAPI PathRenameExtensionW(LPWSTR pszPath, LPCWSTR pszExt)
1741 {
1742         FIXME("%s %s\n", debugstr_w(pszPath), debugstr_w(pszExt));
1743         return FALSE;
1744 }
1745
1746 /*************************************************************************
1747  *      PathSearchAndQualifyA   [SHLWAPI.@]
1748  */
1749 BOOL WINAPI PathSearchAndQualifyA(
1750         LPCSTR pszPath,
1751         LPSTR pszBuf,
1752         UINT cchBuf)
1753 {
1754         FIXME("%s %s 0x%08x\n", pszPath, pszBuf, cchBuf);
1755         return FALSE;
1756 }
1757
1758 /*************************************************************************
1759  *      PathSearchAndQualifyW   [SHLWAPI.@]
1760  */
1761 BOOL WINAPI PathSearchAndQualifyW(
1762         LPCWSTR pszPath,
1763         LPWSTR pszBuf,
1764         UINT cchBuf)
1765 {
1766         FIXME("%s %s 0x%08x\n", debugstr_w(pszPath), debugstr_w(pszBuf), cchBuf);
1767         return FALSE;
1768 }
1769
1770 /*************************************************************************
1771  *      PathSkipRootA   [SHLWAPI.@]
1772  */
1773 LPSTR WINAPI PathSkipRootA(LPCSTR pszPath)
1774 {
1775         FIXME("%s\n", pszPath);
1776         return (LPSTR)pszPath;
1777 }
1778
1779 /*************************************************************************
1780  *      PathSkipRootW   [SHLWAPI.@]
1781  */
1782 LPWSTR WINAPI PathSkipRootW(LPCWSTR pszPath)
1783 {
1784         FIXME("%s\n", debugstr_w(pszPath));
1785         return (LPWSTR)pszPath;
1786 }
1787
1788 /*************************************************************************
1789  *      PathCreateFromUrlA   [SHLWAPI.@]
1790  */
1791 HRESULT WINAPI PathCreateFromUrlA(
1792         LPCSTR pszUrl,
1793         LPSTR pszPath,
1794         LPDWORD pcchPath,
1795         DWORD dwFlags)
1796 {
1797         FIXME("%s %p %p 0x%08lx\n",
1798           pszUrl, pszPath, pcchPath, dwFlags);
1799         return S_OK;
1800 }
1801
1802 /*************************************************************************
1803  *      PathCreateFromUrlW   [SHLWAPI.@]
1804  */
1805 HRESULT WINAPI PathCreateFromUrlW(
1806         LPCWSTR pszUrl,
1807         LPWSTR pszPath,
1808         LPDWORD pcchPath,
1809         DWORD dwFlags)
1810 {
1811         FIXME("%s %p %p 0x%08lx\n",
1812           debugstr_w(pszUrl), pszPath, pcchPath, dwFlags);
1813         return S_OK;
1814 }
1815
1816 /*************************************************************************
1817  *      PathRelativePathToA   [SHLWAPI.@]
1818  */
1819 BOOL WINAPI PathRelativePathToA(
1820         LPSTR pszPath,
1821         LPCSTR pszFrom,
1822         DWORD dwAttrFrom,
1823         LPCSTR pszTo,
1824         DWORD dwAttrTo)
1825 {
1826         FIXME("%s %s 0x%08lx %s 0x%08lx\n",
1827           pszPath, pszFrom, dwAttrFrom, pszTo, dwAttrTo);
1828         return FALSE;
1829 }
1830
1831 /*************************************************************************
1832  *      PathRelativePathToW   [SHLWAPI.@]
1833  */
1834 BOOL WINAPI PathRelativePathToW(
1835         LPWSTR pszPath,
1836         LPCWSTR pszFrom,
1837         DWORD dwAttrFrom,
1838         LPCWSTR pszTo,
1839         DWORD dwAttrTo)
1840 {
1841         FIXME("%s %s 0x%08lx %s 0x%08lx\n",
1842           debugstr_w(pszPath), debugstr_w(pszFrom), dwAttrFrom, debugstr_w(pszTo), dwAttrTo);
1843         return FALSE;
1844 }
1845
1846 /*************************************************************************
1847  *      PathUnmakeSystemFolderA   [SHLWAPI.@]
1848  */
1849 BOOL WINAPI PathUnmakeSystemFolderA(LPCSTR pszPath)
1850 {
1851         FIXME("%s\n", pszPath);
1852         return FALSE;
1853 }
1854
1855 /*************************************************************************
1856  *      PathUnmakeSystemFolderW   [SHLWAPI.@]
1857  */
1858 BOOL WINAPI PathUnmakeSystemFolderW(LPCWSTR pszPath)
1859 {
1860         FIXME("%s\n", debugstr_w(pszPath));
1861         return FALSE;
1862 }
1863
1864 /*
1865         ########## special ##########
1866 */
1867
1868 /*************************************************************************
1869  * PathSetDlgItemPathA   [SHLWAPI.@]
1870  *
1871  * NOTES
1872  *  use PathCompactPath to make sure, the path fits into the control
1873  */
1874 BOOL WINAPI PathSetDlgItemPathA(HWND hDlg, int id, LPCSTR pszPath)
1875 {       TRACE("%x %x %s\n",hDlg, id, pszPath);
1876         return SetDlgItemTextA(hDlg, id, pszPath);
1877 }
1878
1879 /*************************************************************************
1880  * PathSetDlgItemPathW   [SHLWAPI.@]
1881  */
1882 BOOL WINAPI PathSetDlgItemPathW(HWND hDlg, int id, LPCWSTR pszPath)
1883 {       TRACE("%x %x %s\n",hDlg, id, debugstr_w(pszPath));
1884         return SetDlgItemTextW(hDlg, id, pszPath);
1885 }