Ignore:
Timestamp:
Sep 5, 2001, 3:54:53 PM (24 years ago)
Author:
bird
Message:

Added $Id:$ keyword.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shlwapi/path.c

    r6609 r6650  
     1/* $Id: path.c,v 1.14 2001-09-05 13:48:38 bird Exp $ */
    12/*
    23 * Path Functions
    … …  
    4243#define isSlash(x) ((x)=='\\' || (x)=='/')
    4344/*
    44         ########## Combining and Constructing paths ##########
     45    ########## Combining and Constructing paths ##########
    4546*/
    4647
    4748/*************************************************************************
    48  * PathAppendA          [SHLWAPI.@]
    49  * 
     49 * PathAppendA      [SHLWAPI.@]
     50 *
    5051 * NOTES
    5152 *  concat path lpszPath2 onto lpszPath1
    … …  
    5556 */
    5657BOOL WINAPI PathAppendA(
    57         LPSTR lpszPath1,
    58         LPCSTR lpszPath2)
    59 {
    60         TRACE("%s %s\n",lpszPath1, lpszPath2);
    61         while (lpszPath2[0]=='\\') lpszPath2++;
    62         PathCombineA(lpszPath1,lpszPath1,lpszPath2);
    63         return TRUE;
    64 }
    65 
    66 /*************************************************************************
    67  * PathAppendW          [SHLWAPI.@]
     58    LPSTR lpszPath1,
     59    LPCSTR lpszPath2)
     60{
     61    TRACE("%s %s\n",lpszPath1, lpszPath2);
     62    while (lpszPath2[0]=='\\') lpszPath2++;
     63    PathCombineA(lpszPath1,lpszPath1,lpszPath2);
     64    return TRUE;
     65}
     66
     67/*************************************************************************
     68 * PathAppendW      [SHLWAPI.@]
    6869 */
    6970BOOL WINAPI PathAppendW(
    70         LPWSTR lpszPath1,
    71         LPCWSTR lpszPath2)
    72 {
    73         TRACE("%s %s\n",debugstr_w(lpszPath1), debugstr_w(lpszPath2));
    74         while (lpszPath2[0]=='\\') lpszPath2++;
    75         PathCombineW(lpszPath1,lpszPath1,lpszPath2);
    76         return TRUE;
    77 }
    78 
    79 /*************************************************************************
    80  * PathCombineA         [SHLWAPI.@]
    81  * 
     71    LPWSTR lpszPath1,
     72    LPCWSTR lpszPath2)
     73{
     74    TRACE("%s %s\n",debugstr_w(lpszPath1), debugstr_w(lpszPath2));
     75    while (lpszPath2[0]=='\\') lpszPath2++;
     76    PathCombineW(lpszPath1,lpszPath1,lpszPath2);
     77    return TRUE;
     78}
     79
     80/*************************************************************************
     81 * PathCombineA     [SHLWAPI.@]
     82 *
    8283 * NOTES
    8384 *  if lpszFile='.' skip it
    … …  
    8889 */
    8990LPSTR WINAPI PathCombineA(
    90         LPSTR szDest,
    91         LPCSTR lpszDir,
    92         LPCSTR lpszFile)
    93 {
    94         char sTemp[MAX_PATH];
    95         TRACE("%p %p->%s %p->%s\n",szDest, lpszDir, lpszDir, lpszFile, lpszFile);
    96        
    97        
    98         if (!lpszFile || !lpszFile[0] || (lpszFile[0]=='.' && !lpszFile[1]) )
    99         {
    100           strcpy(szDest,lpszDir);
    101           return szDest;
    102         }
    103 
    104         /*  if lpszFile is a complete path don't care about lpszDir */
    105         if (PathGetDriveNumberA(lpszFile) != -1)
    106         {
    107           strcpy(szDest,lpszFile);
    108         }
    109         else if (lpszFile[0] == '\\' )
    110         {
    111           strcpy(sTemp,lpszDir);
    112           PathStripToRootA(sTemp);
    113           strcat(sTemp,lpszFile);
    114           strcpy(szDest,sTemp);
    115         }
    116         else
    117         {
    118           strcpy(sTemp,lpszDir);
    119           PathAddBackslashA(sTemp);
    120           strcat(sTemp,lpszFile);
    121           strcpy(szDest,sTemp);
    122         }
    123         return szDest;
    124 }
    125 
    126 /*************************************************************************
    127  * PathCombineW          [SHLWAPI.@]
     91    LPSTR szDest,
     92    LPCSTR lpszDir,
     93    LPCSTR lpszFile)
     94{
     95    char sTemp[MAX_PATH];
     96    TRACE("%p %p->%s %p->%s\n",szDest, lpszDir, lpszDir, lpszFile, lpszFile);
     97
     98
     99    if (!lpszFile || !lpszFile[0] || (lpszFile[0]=='.' && !lpszFile[1]) )
     100    {
     101      strcpy(szDest,lpszDir);
     102      return szDest;
     103    }
     104
     105    /*  if lpszFile is a complete path don't care about lpszDir */
     106    if (PathGetDriveNumberA(lpszFile) != -1)
     107    {
     108      strcpy(szDest,lpszFile);
     109    }
     110    else if (lpszFile[0] == '\\' )
     111    {
     112      strcpy(sTemp,lpszDir);
     113      PathStripToRootA(sTemp);
     114      strcat(sTemp,lpszFile);
     115      strcpy(szDest,sTemp);
     116    }
     117    else
     118    {
     119      strcpy(sTemp,lpszDir);
     120      PathAddBackslashA(sTemp);
     121      strcat(sTemp,lpszFile);
     122      strcpy(szDest,sTemp);
     123    }
     124    return szDest;
     125}
     126
     127/*************************************************************************
     128 * PathCombineW      [SHLWAPI.@]
    128129 */
    129130LPWSTR WINAPI PathCombineW(
    130         LPWSTR szDest,
    131         LPCWSTR lpszDir,
    132         LPCWSTR lpszFile)
    133 {
    134         WCHAR sTemp[MAX_PATH];
    135         TRACE("%p %p->%s %p->%s\n",szDest, lpszDir, debugstr_w(lpszDir),
    136                         lpszFile, debugstr_w(lpszFile));
    137        
    138        
    139         if (!lpszFile || !lpszFile[0] || (lpszFile[0]==(WCHAR)'.' && !lpszFile[1]) )
    140         {
     131    LPWSTR szDest,
     132    LPCWSTR lpszDir,
     133    LPCWSTR lpszFile)
     134{
     135    WCHAR sTemp[MAX_PATH];
     136    TRACE("%p %p->%s %p->%s\n",szDest, lpszDir, debugstr_w(lpszDir),
     137            lpszFile, debugstr_w(lpszFile));
     138
     139
     140    if (!lpszFile || !lpszFile[0] || (lpszFile[0]==(WCHAR)'.' && !lpszFile[1]) )
     141    {
    141142          strcpyW(szDest,lpszDir);
    142           return szDest;
    143         }
    144 
    145         /*  if lpszFile is a complete path don't care about lpszDir */
    146         if (PathGetDriveNumberW(lpszFile) != -1)
    147         {
     143      return szDest;
     144    }
     145
     146    /*  if lpszFile is a complete path don't care about lpszDir */
     147    if (PathGetDriveNumberW(lpszFile) != -1)
     148    {
    148149            strcpyW(szDest,lpszFile);
    149         }
    150         else if (lpszFile[0] == (WCHAR)'\\' )
    151         {
    152           strcpyW(sTemp,lpszDir);
    153           PathStripToRootW(sTemp);
    154           strcatW(sTemp,lpszFile);
    155           strcpyW(szDest,sTemp);
    156         }
    157         else
    158         {
    159           strcpyW(sTemp,lpszDir);
    160           PathAddBackslashW(sTemp);
    161           strcatW(sTemp,lpszFile);
    162           strcpyW(szDest,sTemp);
    163         }
    164         return szDest;
    165 }
    166 
    167 /*************************************************************************
    168  * PathAddBackslashA    [SHLWAPI.@]
     150    }
     151    else if (lpszFile[0] == (WCHAR)'\\' )
     152    {
     153      strcpyW(sTemp,lpszDir);
     154      PathStripToRootW(sTemp);
     155      strcatW(sTemp,lpszFile);
     156      strcpyW(szDest,sTemp);
     157    }
     158    else
     159    {
     160      strcpyW(sTemp,lpszDir);
     161      PathAddBackslashW(sTemp);
     162      strcatW(sTemp,lpszFile);
     163      strcpyW(szDest,sTemp);
     164    }
     165    return szDest;
     166}
     167
     168/*************************************************************************
     169 * PathAddBackslashA    [SHLWAPI.@]
    169170 *
    170171 * NOTES
    … …  
    173174LPSTR WINAPI PathAddBackslashA(LPSTR lpszPath)
    174175{
    175         int len;
    176         TRACE("%p->%s\n",lpszPath,lpszPath);
    177 
    178         len = strlen(lpszPath);
    179         if (len && lpszPath[len-1]!='\\')
    180         {
    181           lpszPath[len]  = '\\';
    182           lpszPath[len+1]= 0x00;
    183           return lpszPath+len+1;
    184         }
    185         return lpszPath+len;
    186 }
    187 
    188 /*************************************************************************
    189  * PathAddBackslashW    [SHLWAPI.@]
     176    int len;
     177    TRACE("%p->%s\n",lpszPath,lpszPath);
     178
     179    len = strlen(lpszPath);
     180    if (len && lpszPath[len-1]!='\\')
     181    {
     182      lpszPath[len]  = '\\';
     183      lpszPath[len+1]= 0x00;
     184      return lpszPath+len+1;
     185    }
     186    return lpszPath+len;
     187}
     188
     189/*************************************************************************
     190 * PathAddBackslashW    [SHLWAPI.@]
    190191 */
    191192LPWSTR WINAPI PathAddBackslashW(LPWSTR lpszPath)
    192193{
    193         int len;
    194         TRACE("%p->%s\n",lpszPath,debugstr_w(lpszPath));
    195 
    196         len = strlenW(lpszPath);
    197         if (len && lpszPath[len-1]!=(WCHAR)'\\')
    198         {
    199           lpszPath[len]  = (WCHAR)'\\';
    200           lpszPath[len+1]= 0x00;
    201           return lpszPath+len+1;
    202         }
    203         return lpszPath+len;
    204 }
    205 
    206 /*************************************************************************
    207  * PathBuildRootA               [SHLWAPI.@]
    208  */
    209 LPSTR WINAPI PathBuildRootA(LPSTR lpszPath, int drive) 
    210 {
    211         TRACE("%p %i\n",lpszPath, drive);
    212 
    213         strcpy(lpszPath,"A:\\");
    214         lpszPath[0]+=drive;
    215         return lpszPath;
    216 }
    217 
    218 /*************************************************************************
    219  * PathBuildRootW               [SHLWAPI.@]
    220  */
    221 LPWSTR WINAPI PathBuildRootW(LPWSTR lpszPath, int drive) 
    222 {
    223         lpszPath[0] = 'A' + drive;
    224         lpszPath[1] = ':';
    225         lpszPath[2] = '\\';
    226         lpszPath[3] = 0;
    227         TRACE("%p %i\n",debugstr_w(lpszPath), drive);
    228         return lpszPath;
     194    int len;
     195    TRACE("%p->%s\n",lpszPath,debugstr_w(lpszPath));
     196
     197    len = strlenW(lpszPath);
     198    if (len && lpszPath[len-1]!=(WCHAR)'\\')
     199    {
     200      lpszPath[len]  = (WCHAR)'\\';
     201      lpszPath[len+1]= 0x00;
     202      return lpszPath+len+1;
     203    }
     204    return lpszPath+len;
     205}
     206
     207/*************************************************************************
     208 * PathBuildRootA       [SHLWAPI.@]
     209 */
     210LPSTR WINAPI PathBuildRootA(LPSTR lpszPath, int drive)
     211{
     212    TRACE("%p %i\n",lpszPath, drive);
     213
     214    strcpy(lpszPath,"A:\\");
     215    lpszPath[0]+=drive;
     216    return lpszPath;
     217}
     218
     219/*************************************************************************
     220 * PathBuildRootW       [SHLWAPI.@]
     221 */
     222LPWSTR WINAPI PathBuildRootW(LPWSTR lpszPath, int drive)
     223{
     224    lpszPath[0] = 'A' + drive;
     225    lpszPath[1] = ':';
     226    lpszPath[2] = '\\';
     227    lpszPath[3] = 0;
     228    TRACE("%p %i\n",debugstr_w(lpszPath), drive);
     229    return lpszPath;
    229230}
    230231
    231232/*
    232         Extracting Component Parts
     233    Extracting Component Parts
    233234*/
    234235
    235236/*************************************************************************
    236  * PathFindFileNameA    [SHLWAPI.@]
     237 * PathFindFileNameA    [SHLWAPI.@]
    237238 */
    238239LPSTR WINAPI PathFindFileNameA(LPCSTR lpszPath)
    239240{
    240         LPCSTR lastSlash = lpszPath;
    241 
    242         TRACE("%s\n",lpszPath);
    243         while (*lpszPath)
    244         {
    245           if ( isSlash(lpszPath[0]) && lpszPath[1])
    246               lastSlash = lpszPath+1;
    247           lpszPath = CharNextA(lpszPath);
    248         }
    249         return (LPSTR)lastSlash;
    250 
    251 }
    252 
    253 /*************************************************************************
    254  * PathFindFileNameW    [SHLWAPI.@]
     241    LPCSTR lastSlash = lpszPath;
     242
     243    TRACE("%s\n",lpszPath);
     244    while (*lpszPath)
     245    {
     246      if ( isSlash(lpszPath[0]) && lpszPath[1])
     247          lastSlash = lpszPath+1;
     248      lpszPath = CharNextA(lpszPath);
     249    }
     250    return (LPSTR)lastSlash;
     251
     252}
     253
     254/*************************************************************************
     255 * PathFindFileNameW    [SHLWAPI.@]
    255256 */
    256257LPWSTR WINAPI PathFindFileNameW(LPCWSTR lpszPath)
    257258{
    258         LPCWSTR wslash;
    259         wslash = lpszPath;
    260 
    261         TRACE("%s\n",debugstr_w(wslash));
    262         while (lpszPath[0])
    263         {
    264           if (((lpszPath[0]=='\\') || (lpszPath[0]==':')) && lpszPath[1] && lpszPath[1]!='\\')
    265             wslash = lpszPath+1;
    266           lpszPath = CharNextW(lpszPath);
    267         }
    268         return (LPWSTR)wslash; 
    269 }
    270 
    271 /*************************************************************************
    272  * PathFindExtensionA   [SHLWAPI.@]
     259    LPCWSTR wslash;
     260    wslash = lpszPath;
     261
     262    TRACE("%s\n",debugstr_w(wslash));
     263    while (lpszPath[0])
     264    {
     265      if (((lpszPath[0]=='\\') || (lpszPath[0]==':')) && lpszPath[1] && lpszPath[1]!='\\')
     266        wslash = lpszPath+1;
     267      lpszPath = CharNextW(lpszPath);
     268    }
     269    return (LPWSTR)wslash;
     270}
     271
     272/*************************************************************************
     273 * PathFindExtensionA   [SHLWAPI.@]
    273274 *
    274275 * NOTES
    … …  
    276277 */
    277278
    278 LPSTR WINAPI PathFindExtensionA(LPCSTR lpszPath) 
    279 {
    280         LPCSTR   lastpoint = NULL;
    281 
    282         TRACE("%p %s\n",lpszPath,lpszPath);
    283 
    284         while (*lpszPath)
    285         {
    286           if (*lpszPath=='\\'||*lpszPath==' ')
    287             lastpoint=NULL;
    288           if (*lpszPath=='.')
    289             lastpoint=lpszPath;
    290           lpszPath = CharNextA(lpszPath);
    291         }
    292         return (LPSTR)(lastpoint?lastpoint:lpszPath);
    293 }
    294 
    295 /*************************************************************************
    296  * PathFindExtensionW   [SHLWAPI.@]
    297  */
    298 LPWSTR WINAPI PathFindExtensionW(LPCWSTR lpszPath) 
    299 {
    300         LPCWSTR   lastpoint = NULL;
    301 
    302         TRACE("(%p %s)\n",lpszPath,debugstr_w(lpszPath));
    303 
    304         while (*lpszPath)
    305         {
    306           if (*lpszPath==(WCHAR)'\\'||*lpszPath==(WCHAR)' ')
    307             lastpoint=NULL;
    308           if (*lpszPath==(WCHAR)'.')
    309             lastpoint=lpszPath;
    310           lpszPath = CharNextW(lpszPath);
    311         }
    312         return (LPWSTR)(lastpoint?lastpoint:lpszPath);
    313 }
    314 
    315 /*************************************************************************
    316  * PathGetArgsA         [SHLWAPI.@]
     279LPSTR WINAPI PathFindExtensionA(LPCSTR lpszPath)
     280{
     281    LPCSTR   lastpoint = NULL;
     282
     283    TRACE("%p %s\n",lpszPath,lpszPath);
     284
     285    while (*lpszPath)
     286    {
     287      if (*lpszPath=='\\'||*lpszPath==' ')
     288        lastpoint=NULL;
     289      if (*lpszPath=='.')
     290        lastpoint=lpszPath;
     291      lpszPath = CharNextA(lpszPath);
     292    }
     293    return (LPSTR)(lastpoint?lastpoint:lpszPath);
     294}
     295
     296/*************************************************************************
     297 * PathFindExtensionW   [SHLWAPI.@]
     298 */
     299LPWSTR WINAPI PathFindExtensionW(LPCWSTR lpszPath)
     300{
     301    LPCWSTR   lastpoint = NULL;
     302
     303    TRACE("(%p %s)\n",lpszPath,debugstr_w(lpszPath));
     304
     305    while (*lpszPath)
     306    {
     307      if (*lpszPath==(WCHAR)'\\'||*lpszPath==(WCHAR)' ')
     308        lastpoint=NULL;
     309      if (*lpszPath==(WCHAR)'.')
     310        lastpoint=lpszPath;
     311      lpszPath = CharNextW(lpszPath);
     312    }
     313    return (LPWSTR)(lastpoint?lastpoint:lpszPath);
     314}
     315
     316/*************************************************************************
     317 * PathGetArgsA     [SHLWAPI.@]
    317318 *
    318319 * NOTES
    … …  
    323324 *     quoting by '\'
    324325 */
    325 LPSTR WINAPI PathGetArgsA(LPCSTR lpszPath) 
    326 {
    327         BOOL    qflag = FALSE;
    328 
    329         TRACE("%s\n",lpszPath);
    330 
    331         while (*lpszPath)
    332         {
    333           if ((*lpszPath==' ') && !qflag)
    334             return (LPSTR)lpszPath+1;
    335           if (*lpszPath=='"')
    336             qflag=!qflag;
    337           lpszPath = CharNextA(lpszPath);
    338         }
    339         return (LPSTR)lpszPath;
    340 }
    341 
    342 /*************************************************************************
    343  * PathGetArgsW         [SHLWAPI.@]
    344  */
    345 LPWSTR WINAPI PathGetArgsW(LPCWSTR lpszPath) 
    346 {
    347         BOOL    qflag = FALSE;
    348 
    349         TRACE("%s\n",debugstr_w(lpszPath));
    350 
    351         while (*lpszPath)
    352         {
    353           if ((*lpszPath==' ') && !qflag)
    354             return (LPWSTR)lpszPath+1;
    355           if (*lpszPath=='"')
    356             qflag=!qflag;
    357           lpszPath = CharNextW(lpszPath);
    358         }
    359         return (LPWSTR)lpszPath;
    360 }
    361 
    362 /*************************************************************************
    363  * PathGetDriveNumberA  [SHLWAPI.@]
     326LPSTR WINAPI PathGetArgsA(LPCSTR lpszPath)
     327{
     328    BOOL    qflag = FALSE;
     329
     330    TRACE("%s\n",lpszPath);
     331
     332    while (*lpszPath)
     333    {
     334      if ((*lpszPath==' ') && !qflag)
     335        return (LPSTR)lpszPath+1;
     336      if (*lpszPath=='"')
     337        qflag=!qflag;
     338      lpszPath = CharNextA(lpszPath);
     339    }
     340    return (LPSTR)lpszPath;
     341}
     342
     343/*************************************************************************
     344 * PathGetArgsW     [SHLWAPI.@]
     345 */
     346LPWSTR WINAPI PathGetArgsW(LPCWSTR lpszPath)
     347{
     348    BOOL    qflag = FALSE;
     349
     350    TRACE("%s\n",debugstr_w(lpszPath));
     351
     352    while (*lpszPath)
     353    {
     354      if ((*lpszPath==' ') && !qflag)
     355        return (LPWSTR)lpszPath+1;
     356      if (*lpszPath=='"')
     357        qflag=!qflag;
     358      lpszPath = CharNextW(lpszPath);
     359    }
     360    return (LPWSTR)lpszPath;
     361}
     362
     363/*************************************************************************
     364 * PathGetDriveNumberA  [SHLWAPI.@]
    364365 */
    365366int WINAPI PathGetDriveNumberA(LPCSTR lpszPath)
    366367{
    367         int chr = tolower(lpszPath[0]);
    368        
    369         TRACE ("%s\n",debugstr_a(lpszPath));
    370 
    371         if (!lpszPath || lpszPath[1]!=':' || chr < 'a' || chr > 'z') return -1;
    372         return tolower(lpszPath[0]) - 'a' ;
    373 }
    374 
    375 /*************************************************************************
    376  * PathGetDriveNumberW  [SHLWAPI.@]
     368    int chr = tolower(lpszPath[0]);
     369
     370    TRACE ("%s\n",debugstr_a(lpszPath));
     371
     372    if (!lpszPath || lpszPath[1]!=':' || chr < 'a' || chr > 'z') return -1;
     373    return tolower(lpszPath[0]) - 'a' ;
     374}
     375
     376/*************************************************************************
     377 * PathGetDriveNumberW  [SHLWAPI.@]
    377378 */
    378379int WINAPI PathGetDriveNumberW(LPCWSTR lpszPath)
    379380{
    380         int chr = tolowerW(lpszPath[0]);
    381        
    382         TRACE ("%s\n",debugstr_w(lpszPath));
    383 
    384         if (!lpszPath || lpszPath[1]!=':' || chr < 'a' || chr > 'z') return -1;
    385         return tolowerW(lpszPath[0]) - 'a' ;
    386 }
    387 
    388 /*************************************************************************
    389  * PathRemoveFileSpecA  [SHLWAPI.@]
    390  * 
     381    int chr = tolowerW(lpszPath[0]);
     382
     383    TRACE ("%s\n",debugstr_w(lpszPath));
     384
     385    if (!lpszPath || lpszPath[1]!=':' || chr < 'a' || chr > 'z') return -1;
     386    return tolowerW(lpszPath[0]) - 'a' ;
     387}
     388
     389/*************************************************************************
     390 * PathRemoveFileSpecA  [SHLWAPI.@]
     391 *
    391392 * NOTES
    392393 *     truncates passed argument to a valid path
    … …  
    394395 *     "\foo\xx\foo"-> "\foo\xx"
    395396 *     "\" -> "\"
    396  *     "a:\foo" -> "a:\"
     397 *     "a:\foo" -> "a:\"
    397398 */
    398399BOOL WINAPI PathRemoveFileSpecA(LPSTR lpszPath)
    399400{
    400         LPSTR cutplace = lpszPath;
    401         BOOL ret = FALSE;
    402        
    403         TRACE("%s\n",lpszPath);
    404 
    405         if(lpszPath)
    406         {
    407           while (*lpszPath == '\\') cutplace = ++lpszPath;
    408          
    409           while (*lpszPath)
    410           {
    411             if(lpszPath[0] == '\\') cutplace = lpszPath;
    412          
    413             if(lpszPath[0] == ':')
    414             {
    415               cutplace = lpszPath + 1;
    416               if (lpszPath[1] == '\\') cutplace++;
    417               lpszPath++;
    418             }
    419             lpszPath = CharNextA(lpszPath);
    420             if (!lpszPath) break;
    421           }
    422          
    423           ret = (*cutplace!='\0');
    424           *cutplace = '\0';
    425         }
    426         return ret;
    427 }
    428 
    429 /*************************************************************************
    430  * PathRemoveFileSpecW  [SHLWAPI.@]
     401    LPSTR cutplace = lpszPath;
     402    BOOL ret = FALSE;
     403
     404    TRACE("%s\n",lpszPath);
     405
     406    if(lpszPath)
     407    {
     408      while (*lpszPath == '\\') cutplace = ++lpszPath;
     409
     410      while (*lpszPath)
     411      {
     412        if(lpszPath[0] == '\\') cutplace = lpszPath;
     413
     414        if(lpszPath[0] == ':')
     415        {
     416          cutplace = lpszPath + 1;
     417          if (lpszPath[1] == '\\') cutplace++;
     418          lpszPath++;
     419        }
     420        lpszPath = CharNextA(lpszPath);
     421        if (!lpszPath) break;
     422      }
     423
     424      ret = (*cutplace!='\0');
     425      *cutplace = '\0';
     426    }
     427    return ret;
     428}
     429
     430/*************************************************************************
     431 * PathRemoveFileSpecW  [SHLWAPI.@]
    431432 */
    432433BOOL WINAPI PathRemoveFileSpecW(LPWSTR lpszPath)
    433434{
    434         LPWSTR cutplace = lpszPath;
    435         BOOL ret = FALSE;
    436 
    437         TRACE("%s\n",debugstr_w(lpszPath));
    438 
    439         if(lpszPath)
    440         {
    441           while (*lpszPath == '\\') cutplace = ++lpszPath;
    442          
    443           while (*lpszPath)
    444           {
    445             if(lpszPath[0] == '\\') cutplace = lpszPath;
    446          
    447             if(lpszPath[0] == ':')
    448             {
    449               cutplace = lpszPath + 1;
    450               if (lpszPath[1] == '\\') cutplace++;
    451               lpszPath++;
    452             }
    453             lpszPath = CharNextW(lpszPath);
    454             if (!lpszPath) break;
    455           }
    456          
    457           ret = (*cutplace!='\0');
    458           *cutplace = '\0';
    459         }
    460         return ret;
    461 }
    462 
    463 /*************************************************************************
    464  * PathStripPathA       [SHELLWAPI.@]
    465  * 
     435    LPWSTR cutplace = lpszPath;
     436    BOOL ret = FALSE;
     437
     438    TRACE("%s\n",debugstr_w(lpszPath));
     439
     440    if(lpszPath)
     441    {
     442      while (*lpszPath == '\\') cutplace = ++lpszPath;
     443
     444      while (*lpszPath)
     445      {
     446        if(lpszPath[0] == '\\') cutplace = lpszPath;
     447
     448        if(lpszPath[0] == ':')
     449        {
     450          cutplace = lpszPath + 1;
     451          if (lpszPath[1] == '\\') cutplace++;
     452          lpszPath++;
     453        }
     454        lpszPath = CharNextW(lpszPath);
     455        if (!lpszPath) break;
     456      }
     457
     458      ret = (*cutplace!='\0');
     459      *cutplace = '\0';
     460    }
     461    return ret;
     462}
     463
     464/*************************************************************************
     465 * PathStripPathA   [SHELLWAPI.@]
     466 *
    466467 * NOTES
    467468 *  removes the path from the beginning of a filename
    … …  
    469470void WINAPI PathStripPathA(LPSTR lpszPath)
    470471{
    471         LPSTR lpszFileName = PathFindFileNameA(lpszPath);
    472 
    473         TRACE("%s\n", lpszPath);
    474 
    475         if(lpszFileName)
    476           RtlMoveMemory(lpszPath, lpszFileName, strlen(lpszFileName)+1);
    477 }
    478 
    479 /*************************************************************************
    480  * PathStripPathW       [SHELLWAPI.@]
     472    LPSTR lpszFileName = PathFindFileNameA(lpszPath);
     473
     474    TRACE("%s\n", lpszPath);
     475
     476    if(lpszFileName)
     477      RtlMoveMemory(lpszPath, lpszFileName, strlen(lpszFileName)+1);
     478}
     479
     480/*************************************************************************
     481 * PathStripPathW   [SHELLWAPI.@]
    481482 */
    482483void WINAPI PathStripPathW(LPWSTR lpszPath)
    483484{
    484         LPWSTR lpszFileName = PathFindFileNameW(lpszPath);
    485 
    486         TRACE("%s\n", debugstr_w(lpszPath));
    487         if(lpszFileName)
    488           RtlMoveMemory(lpszPath, lpszFileName, (strlenW(lpszFileName)+1)*sizeof(WCHAR));
    489 }
    490 
    491 /*************************************************************************
    492  * PathStripToRootA     [SHLWAPI.@]
     485    LPWSTR lpszFileName = PathFindFileNameW(lpszPath);
     486
     487    TRACE("%s\n", debugstr_w(lpszPath));
     488    if(lpszFileName)
     489      RtlMoveMemory(lpszPath, lpszFileName, (strlenW(lpszFileName)+1)*sizeof(WCHAR));
     490}
     491
     492/*************************************************************************
     493 * PathStripToRootA [SHLWAPI.@]
    493494 */
    494495BOOL WINAPI PathStripToRootA(LPSTR lpszPath)
    495496{
    496         TRACE("%s\n", lpszPath);
    497 
    498         if (!lpszPath) return FALSE;
    499         while(!PathIsRootA(lpszPath))
    500           if (!PathRemoveFileSpecA(lpszPath)) return FALSE;
    501         return TRUE;
    502 }
    503 
    504 /*************************************************************************
    505  * PathStripToRootW     [SHLWAPI.@]
     497    TRACE("%s\n", lpszPath);
     498
     499    if (!lpszPath) return FALSE;
     500    while(!PathIsRootA(lpszPath))
     501      if (!PathRemoveFileSpecA(lpszPath)) return FALSE;
     502    return TRUE;
     503}
     504
     505/*************************************************************************
     506 * PathStripToRootW [SHLWAPI.@]
    506507 */
    507508BOOL WINAPI PathStripToRootW(LPWSTR lpszPath)
    508509{
    509         TRACE("%s\n", debugstr_w(lpszPath));
    510 
    511         if (!lpszPath) return FALSE;
    512         while(!PathIsRootW(lpszPath))
    513           if (!PathRemoveFileSpecW(lpszPath)) return FALSE;
    514         return TRUE;
    515 }
    516 
    517 /*************************************************************************
    518  * PathRemoveArgsA      [SHLWAPI.@]
     510    TRACE("%s\n", debugstr_w(lpszPath));
     511
     512    if (!lpszPath) return FALSE;
     513    while(!PathIsRootW(lpszPath))
     514      if (!PathRemoveFileSpecW(lpszPath)) return FALSE;
     515    return TRUE;
     516}
     517
     518/*************************************************************************
     519 * PathRemoveArgsA  [SHLWAPI.@]
    519520 *
    520521 */
    521522void WINAPI PathRemoveArgsA(LPSTR lpszPath)
    522523{
    523         TRACE("%s\n",lpszPath);
    524        
    525         if(lpszPath)
    526         {
    527           LPSTR lpszArgs = PathGetArgsA(lpszPath);
    528           if (!*lpszArgs)
    529           {
    530             LPSTR lpszLastChar = CharPrevA(lpszPath, lpszArgs);
    531             if(*lpszLastChar==' ') *lpszLastChar = '\0';
    532           }
    533         }
    534 }
    535 
    536 /*************************************************************************
    537  * PathRemoveArgsW      [SHLWAPI.@]
     524    TRACE("%s\n",lpszPath);
     525
     526    if(lpszPath)
     527    {
     528      LPSTR lpszArgs = PathGetArgsA(lpszPath);
     529      if (!*lpszArgs)
     530      {
     531        LPSTR lpszLastChar = CharPrevA(lpszPath, lpszArgs);
     532        if(*lpszLastChar==' ') *lpszLastChar = '\0';
     533      }
     534    }
     535}
     536
     537/*************************************************************************
     538 * PathRemoveArgsW  [SHLWAPI.@]
    538539 */
    539540void WINAPI PathRemoveArgsW(LPWSTR lpszPath)
    540541{
    541         TRACE("%s\n", debugstr_w(lpszPath));
    542 
    543         if(lpszPath)
    544         {
    545           LPWSTR lpszArgs = PathGetArgsW(lpszPath);
    546           if (!*lpszArgs)
    547           {
    548             LPWSTR lpszLastChar = CharPrevW(lpszPath, lpszArgs);
    549             if(*lpszLastChar==' ') *lpszLastChar = '\0';
    550           }
    551         }
    552 }
    553 
    554 /*************************************************************************
    555  * PathRemoveExtensionA         [SHLWAPI.@]
     542    TRACE("%s\n", debugstr_w(lpszPath));
     543
     544    if(lpszPath)
     545    {
     546      LPWSTR lpszArgs = PathGetArgsW(lpszPath);
     547      if (!*lpszArgs)
     548      {
     549        LPWSTR lpszLastChar = CharPrevW(lpszPath, lpszArgs);
     550        if(*lpszLastChar==' ') *lpszLastChar = '\0';
     551      }
     552    }
     553}
     554
     555/*************************************************************************
     556 * PathRemoveExtensionA     [SHLWAPI.@]
    556557 */
    557558void WINAPI PathRemoveExtensionA(LPSTR lpszPath)
    558559{
    559         LPSTR lpszExtension = PathFindExtensionA(lpszPath);
    560 
    561         TRACE("%s\n", lpszPath);
    562 
    563         if (lpszExtension) *lpszExtension='\0';
    564 }
    565 
    566 /*************************************************************************
    567  * PathRemoveExtensionW         [SHLWAPI.@]
     560    LPSTR lpszExtension = PathFindExtensionA(lpszPath);
     561
     562    TRACE("%s\n", lpszPath);
     563
     564    if (lpszExtension) *lpszExtension='\0';
     565}
     566
     567/*************************************************************************
     568 * PathRemoveExtensionW     [SHLWAPI.@]
    568569 */
    569570void WINAPI PathRemoveExtensionW(LPWSTR lpszPath)
    570571{
    571         LPWSTR lpszExtension = PathFindExtensionW(lpszPath);
    572 
    573         TRACE("%s\n", debugstr_w(lpszPath));
    574 
    575         if (lpszExtension) *lpszExtension='\0';
    576 }
    577 
    578 /*************************************************************************
    579  * PathRemoveBackslashA [SHLWAPI.@]
     572    LPWSTR lpszExtension = PathFindExtensionW(lpszPath);
     573
     574    TRACE("%s\n", debugstr_w(lpszPath));
     575
     576    if (lpszExtension) *lpszExtension='\0';
     577}
     578
     579/*************************************************************************
     580 * PathRemoveBackslashA [SHLWAPI.@]
    580581 *
    581582 * If the path ends in a backslash it is replaced by a NULL
    582583 * and the address of the NULL is returned
    583  * Otherwise 
     584 * Otherwise
    584585 * the address of the last character is returned.
    585586 *
    … …  
    589590LPSTR WINAPI PathRemoveBackslashA( LPSTR lpszPath )
    590591{
    591         int len;
    592         LPSTR szTemp = NULL;
    593        
    594         if(lpszPath)
    595         {
    596           len = strlen(lpszPath);
    597           szTemp = CharPrevA(lpszPath, lpszPath+len);
    598           if (! PathIsRootA(lpszPath))
    599           {
    600             if (*szTemp == '\\') *szTemp = '\0';
    601           }
    602         }
    603         return szTemp;
    604 }
    605 
    606 /*************************************************************************
    607  * PathRemoveBackslashW [SHLWAPI.@]
     592    int len;
     593    LPSTR szTemp = NULL;
     594
     595    if(lpszPath)
     596    {
     597      len = strlen(lpszPath);
     598      szTemp = CharPrevA(lpszPath, lpszPath+len);
     599      if (! PathIsRootA(lpszPath))
     600      {
     601        if (*szTemp == '\\') *szTemp = '\0';
     602      }
     603    }
     604    return szTemp;
     605}
     606
     607/*************************************************************************
     608 * PathRemoveBackslashW [SHLWAPI.@]
    608609 */
    609610LPWSTR WINAPI PathRemoveBackslashW( LPWSTR lpszPath )
    610611{
    611         int len;
    612         LPWSTR szTemp = NULL;
    613        
    614         if(lpszPath)
    615         {
    616           len = strlenW(lpszPath);
    617           szTemp = CharPrevW(lpszPath, lpszPath+len);
    618           if (! PathIsRootW(lpszPath))
    619           {
    620             if (*szTemp == '\\') *szTemp = '\0';
    621           }
    622         }
    623         return szTemp;
     612    int len;
     613    LPWSTR szTemp = NULL;
     614
     615    if(lpszPath)
     616    {
     617      len = strlenW(lpszPath);
     618      szTemp = CharPrevW(lpszPath, lpszPath+len);
     619      if (! PathIsRootW(lpszPath))
     620      {
     621        if (*szTemp == '\\') *szTemp = '\0';
     622      }
     623    }
     624    return szTemp;
    624625}
    625626
    626627
    627628/*
    628         Path Manipulations
     629    Path Manipulations
    629630*/
    630631
    631632/*************************************************************************
    632633 * PathRemoveBlanksA [SHLWAPI.@]
    633  * 
     634 *
    634635 * NOTES
    635636 *     remove spaces from beginning and end of passed string
    … …  
    637638void WINAPI PathRemoveBlanksA(LPSTR str)
    638639{
    639         LPSTR x = str;
    640 
    641         TRACE("%s\n",str);
    642 
    643         if(str)
    644         {
    645           while (*x==' ') x = CharNextA(x);
    646           if (x!=str) strcpy(str,x);
    647           x=str+strlen(str)-1;
    648           while (*x==' ') x = CharPrevA(str, x);
    649           if (*x==' ') *x='\0';
    650         }
     640    LPSTR x = str;
     641
     642    TRACE("%s\n",str);
     643
     644    if(str)
     645    {
     646      while (*x==' ') x = CharNextA(x);
     647      if (x!=str) strcpy(str,x);
     648      x=str+strlen(str)-1;
     649      while (*x==' ') x = CharPrevA(str, x);
     650      if (*x==' ') *x='\0';
     651    }
    651652}
    652653
    … …  
    656657void WINAPI PathRemoveBlanksW(LPWSTR str)
    657658{
    658         LPWSTR x = str;
    659 
    660         TRACE("%s\n",debugstr_w(str));
    661 
    662         if(str)
    663         {
    664           while (*x==' ') x = CharNextW(x);
    665           if (x!=str) strcpyW(str,x);
    666           x=str+strlenW(str)-1;
    667           while (*x==' ') x = CharPrevW(str, x);
    668           if (*x==' ') *x='\0';
    669         }
     659    LPWSTR x = str;
     660
     661    TRACE("%s\n",debugstr_w(str));
     662
     663    if(str)
     664    {
     665      while (*x==' ') x = CharNextW(x);
     666      if (x!=str) strcpyW(str,x);
     667      x=str+strlenW(str)-1;
     668      while (*x==' ') x = CharPrevW(str, x);
     669      if (*x==' ') *x='\0';
     670    }
    670671}
    671672
    672673/*************************************************************************
    673674 * PathQuoteSpacesA [SHLWAPI.@]
    674  * 
     675 *
    675676 */
    676677LPSTR WINAPI PathQuoteSpacesA(LPSTR lpszPath)
    677678{
    678         TRACE("%s\n",lpszPath);
    679 
    680         if(StrChrA(lpszPath,' '))
    681         {
    682           int len = strlen(lpszPath);
    683           RtlMoveMemory(lpszPath+1, lpszPath, len);
    684           *(lpszPath++) = '"';
    685           lpszPath += len;
    686           *(lpszPath++) = '"';
    687           *(lpszPath) = '\0';
    688           return --lpszPath;
    689         }
    690         return 0;
     679    TRACE("%s\n",lpszPath);
     680
     681    if(StrChrA(lpszPath,' '))
     682    {
     683      int len = strlen(lpszPath);
     684      RtlMoveMemory(lpszPath+1, lpszPath, len);
     685      *(lpszPath++) = '"';
     686      lpszPath += len;
     687      *(lpszPath++) = '"';
     688      *(lpszPath) = '\0';
     689      return --lpszPath;
     690    }
     691    return 0;
    691692}
    692693
    … …  
    696697LPWSTR WINAPI PathQuoteSpacesW(LPWSTR lpszPath)
    697698{
    698         TRACE("%s\n",debugstr_w(lpszPath));
    699 
    700         if(StrChrW(lpszPath,' '))
    701         {
    702           int len = strlenW(lpszPath);
    703           RtlMoveMemory(lpszPath+1, lpszPath, len*sizeof(WCHAR));
    704           *(lpszPath++) = '"';
    705           lpszPath += len;
    706           *(lpszPath++) = '"';
    707           *(lpszPath) = '\0';
    708           return --lpszPath;
    709         }
    710         return 0;
     699    TRACE("%s\n",debugstr_w(lpszPath));
     700
     701    if(StrChrW(lpszPath,' '))
     702    {
     703      int len = strlenW(lpszPath);
     704      RtlMoveMemory(lpszPath+1, lpszPath, len*sizeof(WCHAR));
     705      *(lpszPath++) = '"';
     706      lpszPath += len;
     707      *(lpszPath++) = '"';
     708      *(lpszPath) = '\0';
     709      return --lpszPath;
     710    }
     711    return 0;
    711712}
    712713
    713714/*************************************************************************
    714715 * PathUnquoteSpacesA [SHLWAPI.@]
    715  * 
     716 *
    716717 * NOTES
    717718 *     unquote string (remove ")
    718719 */
    719 VOID WINAPI PathUnquoteSpacesA(LPSTR str) 
    720 {
    721         DWORD len = strlen(str);
    722 
    723         TRACE("%s\n",str);
    724 
    725         if (*str!='"')
    726           return;
    727         if (str[len-1]!='"')
    728           return;
    729         str[len-1]='\0';
    730         strcpy(str,str+1);
    731         return;
     720VOID WINAPI PathUnquoteSpacesA(LPSTR str)
     721{
     722    DWORD len = strlen(str);
     723
     724    TRACE("%s\n",str);
     725
     726    if (*str!='"')
     727      return;
     728    if (str[len-1]!='"')
     729      return;
     730    str[len-1]='\0';
     731    strcpy(str,str+1);
     732    return;
    732733}
    733734
    … …  
    735736 * PathUnquoteSpacesW [SHLWAPI.@]
    736737 */
    737 VOID WINAPI PathUnquoteSpacesW(LPWSTR str) 
    738 {
    739         DWORD len = strlenW(str);
    740 
    741         TRACE("%s\n",debugstr_w(str));
    742 
    743         if (*str!='"')
    744           return;
    745         if (str[len-1]!='"')
    746           return;
    747         str[len-1]='\0';
    748         strcpyW(str,str+1);
    749         return;
    750 }
    751 
    752 /*************************************************************************
    753  * PathParseIconLocationA       [SHLWAPI.@]
     738VOID WINAPI PathUnquoteSpacesW(LPWSTR str)
     739{
     740    DWORD len = strlenW(str);
     741
     742    TRACE("%s\n",debugstr_w(str));
     743
     744    if (*str!='"')
     745      return;
     746    if (str[len-1]!='"')
     747      return;
     748    str[len-1]='\0';
     749    strcpyW(str,str+1);
     750    return;
     751}
     752
     753/*************************************************************************
     754 * PathParseIconLocationA   [SHLWAPI.@]
    754755 */
    755756int WINAPI PathParseIconLocationA(LPSTR lpszPath)
    756757{
    757         LPSTR lpstrComma = strchr(lpszPath, ',');
    758        
    759         FIXME("%s stub\n", debugstr_a(lpszPath));
    760 
    761         if (lpstrComma && lpstrComma[1])
    762         {
    763           lpstrComma[0]='\0';
    764 /*        return atoi(&lpstrComma[1]);  FIXME */
    765         }
    766        
    767         PathUnquoteSpacesA(lpszPath);
    768         return 0;
    769 }
    770 
    771 /*************************************************************************
    772  * PathParseIconLocationW       [SHLWAPI.@]
     758    LPSTR lpstrComma = strchr(lpszPath, ',');
     759
     760    FIXME("%s stub\n", debugstr_a(lpszPath));
     761
     762    if (lpstrComma && lpstrComma[1])
     763    {
     764      lpstrComma[0]='\0';
     765/*    return atoi(&lpstrComma[1]);  FIXME */
     766    }
     767
     768    PathUnquoteSpacesA(lpszPath);
     769    return 0;
     770}
     771
     772/*************************************************************************
     773 * PathParseIconLocationW   [SHLWAPI.@]
    773774 */
    774775int WINAPI PathParseIconLocationW(LPWSTR lpszPath)
    775776{
    776         LPWSTR lpstrComma = strchrW(lpszPath, ',');
    777        
    778         FIXME("%s stub\n", debugstr_w(lpszPath));
    779 
    780         if (lpstrComma && lpstrComma[1])
    781         {
    782           lpstrComma[0]='\0';
    783 /*        return _wtoi(&lpstrComma[1]); FIXME */
    784         }
    785         PathUnquoteSpacesW(lpszPath);
    786         return 0;
     777    LPWSTR lpstrComma = strchrW(lpszPath, ',');
     778
     779    FIXME("%s stub\n", debugstr_w(lpszPath));
     780
     781    if (lpstrComma && lpstrComma[1])
     782    {
     783      lpstrComma[0]='\0';
     784/*    return _wtoi(&lpstrComma[1]); FIXME */
     785    }
     786    PathUnquoteSpacesW(lpszPath);
     787    return 0;
    787788}
    788789
    789790/*
    790         ########## cleaning and resolving paths ##########
    791  */
    792 
    793 /*************************************************************************
    794  * PathFindOnPathA      [SHLWAPI.@]
     791    ########## cleaning and resolving paths ##########
     792 */
     793
     794/*************************************************************************
     795 * PathFindOnPathA  [SHLWAPI.@]
    795796 */
    796797BOOL WINAPI PathFindOnPathA(LPSTR sFile, LPCSTR sOtherDirs)
    797798{
    798         FIXME("%s %s\n",sFile, sOtherDirs);
    799         return FALSE;
    800 }
    801 
    802 /*************************************************************************
    803  * PathFindOnPathW      [SHLWAPI.@]
     799    FIXME("%s %s\n",sFile, sOtherDirs);
     800    return FALSE;
     801}
     802
     803/*************************************************************************
     804 * PathFindOnPathW  [SHLWAPI.@]
    804805 */
    805806BOOL WINAPI PathFindOnPathW(LPWSTR sFile, LPCWSTR sOtherDirs)
    806807{
    807         FIXME("%s %s\n",debugstr_w(sFile), debugstr_w(sOtherDirs));
    808         return FALSE;
    809 }
    810 
    811 /*************************************************************************
    812  *      PathCompactPathExA   [SHLWAPI.@]
     808    FIXME("%s %s\n",debugstr_w(sFile), debugstr_w(sOtherDirs));
     809    return FALSE;
     810}
     811
     812/*************************************************************************
     813 *  PathCompactPathExA   [SHLWAPI.@]
    813814 */
    814815BOOL WINAPI PathCompactPathExA(
    815         LPSTR pszOut,
    816         LPCSTR pszSrc,
    817         UINT cchMax,
    818         DWORD dwFlags)
    819 {
    820         FIXME("%p %s 0x%08x 0x%08lx\n", pszOut, pszSrc, cchMax, dwFlags);
    821         return FALSE;
    822 }
    823 
    824 /*************************************************************************
    825  *      PathCompactPathExW   [SHLWAPI.@]
     816    LPSTR pszOut,
     817    LPCSTR pszSrc,
     818    UINT cchMax,
     819    DWORD dwFlags)
     820{
     821    FIXME("%p %s 0x%08x 0x%08lx\n", pszOut, pszSrc, cchMax, dwFlags);
     822    return FALSE;
     823}
     824
     825/*************************************************************************
     826 *  PathCompactPathExW   [SHLWAPI.@]
    826827 */
    827828BOOL WINAPI PathCompactPathExW(
    828         LPWSTR pszOut,
    829         LPCWSTR pszSrc,
    830         UINT cchMax,
    831         DWORD dwFlags)
    832 {
    833         FIXME("%p %s 0x%08x 0x%08lx\n", pszOut, debugstr_w(pszSrc), cchMax, dwFlags);
    834         return FALSE;
     829    LPWSTR pszOut,
     830    LPCWSTR pszSrc,
     831    UINT cchMax,
     832    DWORD dwFlags)
     833{
     834    FIXME("%p %s 0x%08x 0x%08lx\n", pszOut, debugstr_w(pszSrc), cchMax, dwFlags);
     835    return FALSE;
    835836}
    836837
    837838/*
    838         ########## Path Testing ##########
     839    ########## Path Testing ##########
    839840*/
    840841
    841842/*************************************************************************
    842  * PathIsUNCA           [SHLWAPI.@]
    843  * 
     843 * PathIsUNCA       [SHLWAPI.@]
     844 *
    844845 * NOTES
    845846 *     PathIsUNC(char*path);
    846847 */
    847 BOOL WINAPI PathIsUNCA(LPCSTR lpszPath) 
    848 {
    849         TRACE("%s\n",lpszPath);
    850 
    851         return (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'));
    852 }
    853 
    854 /*************************************************************************
    855  * PathIsUNCW           [SHLWAPI.@]
    856  */
    857 BOOL WINAPI PathIsUNCW(LPCWSTR lpszPath) 
    858 {
    859         TRACE("%s\n",debugstr_w(lpszPath));
    860 
    861         return (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'));
    862 }
    863 
    864 /*************************************************************************
    865  *  PathIsRelativeA     [SHLWAPI.@]
     848BOOL WINAPI PathIsUNCA(LPCSTR lpszPath)
     849{
     850    TRACE("%s\n",lpszPath);
     851
     852    return (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'));
     853}
     854
     855/*************************************************************************
     856 * PathIsUNCW       [SHLWAPI.@]
     857 */
     858BOOL WINAPI PathIsUNCW(LPCWSTR lpszPath)
     859{
     860    TRACE("%s\n",debugstr_w(lpszPath));
     861
     862    return (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'));
     863}
     864
     865/*************************************************************************
     866 *  PathIsRelativeA [SHLWAPI.@]
    866867 */
    867868BOOL WINAPI PathIsRelativeA (LPCSTR lpszPath)
    868869{
    869         TRACE("lpszPath=%s\n",lpszPath);
    870 
    871         return (lpszPath && (lpszPath[0]!='\\' && lpszPath[1]!=':'));
    872 }
    873 
    874 /*************************************************************************
    875  *  PathIsRelativeW     [SHLWAPI.@]
     870    TRACE("lpszPath=%s\n",lpszPath);
     871
     872    return (lpszPath && (lpszPath[0]!='\\' && lpszPath[1]!=':'));
     873}
     874
     875/*************************************************************************
     876 *  PathIsRelativeW [SHLWAPI.@]
    876877 */
    877878BOOL WINAPI PathIsRelativeW (LPCWSTR lpszPath)
    878879{
    879         TRACE("lpszPath=%s\n",debugstr_w(lpszPath));
    880 
    881         return (lpszPath && (lpszPath[0]!='\\' && lpszPath[1]!=':'));
    882 }
    883 
    884 /*************************************************************************
    885  * PathIsRootA          [SHLWAPI.@]
     880    TRACE("lpszPath=%s\n",debugstr_w(lpszPath));
     881
     882    return (lpszPath && (lpszPath[0]!='\\' && lpszPath[1]!=':'));
     883}
     884
     885/*************************************************************************
     886 * PathIsRootA      [SHLWAPI.@]
    886887 *
    887888 * notes
    … …  
    890891BOOL WINAPI PathIsRootA(LPCSTR lpszPath)
    891892{
    892         TRACE("%s\n",lpszPath);
    893 
    894         /* X:\ */
    895         if (lpszPath[1]==':' && lpszPath[2]=='\\' && lpszPath[3]=='\0')
    896           return TRUE;
    897 
    898         /* "\" */
    899         if (lpszPath[0]=='\\' && lpszPath[1]=='\0')
    900           return TRUE;
    901 
    902         /* UNC "\\<computer>\<share>" */
    903         if (lpszPath[0]=='\\' && lpszPath[1]=='\\')             
    904         {
    905           int foundbackslash = 0;
    906           lpszPath += 2;
    907           while (*lpszPath)
    908           {
    909             if (*lpszPath=='\\') foundbackslash++;
    910             lpszPath = CharNextA(lpszPath);
    911           }
    912           if (foundbackslash <= 1)
    913             return TRUE;
    914         }
    915         return FALSE;
    916 }
    917 
    918 /*************************************************************************
    919  * PathIsRootW          [SHLWAPI.@]
    920  */
    921 BOOL WINAPI PathIsRootW(LPCWSTR lpszPath) 
    922 {
    923         TRACE("%s\n",debugstr_w(lpszPath));
    924 
    925         /* X:\ */
    926         if (lpszPath[1]==':' && lpszPath[2]=='\\' && lpszPath[3]=='\0')
    927           return TRUE;
    928 
    929         /* "\" */
    930         if (lpszPath[0]=='\\' && lpszPath[1]=='\0')
    931           return TRUE;
    932 
    933         /* UNC "\\<computer>\<share>" */
    934         if (lpszPath[0]=='\\' && lpszPath[1]=='\\')             
    935         {
    936           int foundbackslash = 0;
    937           lpszPath += 2;
    938           while (*lpszPath)
    939           {
    940             if (*lpszPath=='\\') foundbackslash++;
    941             lpszPath = CharNextW(lpszPath);
    942           }
    943           if (foundbackslash <= 1)
    944             return TRUE;
    945         }
    946         return FALSE;
    947 
    948 }
    949 
    950 /*************************************************************************
    951  * PathIsDirectoryA     [SHLWAPI.@]
     893    TRACE("%s\n",lpszPath);
     894
     895    /* X:\ */
     896    if (lpszPath[1]==':' && lpszPath[2]=='\\' && lpszPath[3]=='\0')
     897      return TRUE;
     898
     899    /* "\" */
     900    if (lpszPath[0]=='\\' && lpszPath[1]=='\0')
     901      return TRUE;
     902
     903    /* UNC "\\<computer>\<share>" */
     904    if (lpszPath[0]=='\\' && lpszPath[1]=='\\')
     905    {
     906      int foundbackslash = 0;
     907      lpszPath += 2;
     908      while (*lpszPath)
     909      {
     910        if (*lpszPath=='\\') foundbackslash++;
     911        lpszPath = CharNextA(lpszPath);
     912      }
     913      if (foundbackslash <= 1)
     914        return TRUE;
     915    }
     916    return FALSE;
     917}
     918
     919/*************************************************************************
     920 * PathIsRootW      [SHLWAPI.@]
     921 */
     922BOOL WINAPI PathIsRootW(LPCWSTR lpszPath)
     923{
     924    TRACE("%s\n",debugstr_w(lpszPath));
     925
     926    /* X:\ */
     927    if (lpszPath[1]==':' && lpszPath[2]=='\\' && lpszPath[3]=='\0')
     928      return TRUE;
     929
     930    /* "\" */
     931    if (lpszPath[0]=='\\' && lpszPath[1]=='\0')
     932      return TRUE;
     933
     934    /* UNC "\\<computer>\<share>" */
     935    if (lpszPath[0]=='\\' && lpszPath[1]=='\\')
     936    {
     937      int foundbackslash = 0;
     938      lpszPath += 2;
     939      while (*lpszPath)
     940      {
     941        if (*lpszPath=='\\') foundbackslash++;
     942        lpszPath = CharNextW(lpszPath);
     943      }
     944      if (foundbackslash <= 1)
     945        return TRUE;
     946    }
     947    return FALSE;
     948
     949}
     950
     951/*************************************************************************
     952 * PathIsDirectoryA [SHLWAPI.@]
    952953 */
    953954BOOL WINAPI PathIsDirectoryA(LPCSTR lpszPath)
    954955{
    955         DWORD dwAttr;
    956 
    957         TRACE("%s\n", debugstr_a(lpszPath));
    958 
    959         dwAttr = GetFileAttributesA(lpszPath);
    960         return  (dwAttr != -1) ? dwAttr & FILE_ATTRIBUTE_DIRECTORY : 0;
    961 }
    962 
    963 /*************************************************************************
    964  * PathIsDirectoryW     [SHLWAPI.@]
     956    DWORD dwAttr;
     957
     958    TRACE("%s\n", debugstr_a(lpszPath));
     959
     960    dwAttr = GetFileAttributesA(lpszPath);
     961    return  (dwAttr != -1) ? dwAttr & FILE_ATTRIBUTE_DIRECTORY : 0;
     962}
     963
     964/*************************************************************************
     965 * PathIsDirectoryW [SHLWAPI.@]
    965966 */
    966967BOOL WINAPI PathIsDirectoryW(LPCWSTR lpszPath)
    967968{
    968         DWORD dwAttr;
    969        
    970         TRACE("%s\n", debugstr_w(lpszPath));
    971 
    972         dwAttr = GetFileAttributesW(lpszPath);
    973         return  (dwAttr != -1) ? dwAttr & FILE_ATTRIBUTE_DIRECTORY : 0;
    974 }
    975 
    976 /*************************************************************************
    977  * PathFileExistsA      [SHLWAPI.@]
    978  * 
     969    DWORD dwAttr;
     970
     971    TRACE("%s\n", debugstr_w(lpszPath));
     972
     973    dwAttr = GetFileAttributesW(lpszPath);
     974    return  (dwAttr != -1) ? dwAttr & FILE_ATTRIBUTE_DIRECTORY : 0;
     975}
     976
     977/*************************************************************************
     978 * PathFileExistsA  [SHLWAPI.@]
     979 *
    979980 * NOTES
    980981 *     file_exists(char *fn);
    981982 */
    982 BOOL WINAPI PathFileExistsA(LPCSTR lpszPath) 
    983 {
    984         TRACE("%s\n",lpszPath);
    985         return  (GetFileAttributesA(lpszPath)!=-1);
    986 }
    987 
    988 /*************************************************************************
    989  * PathFileExistsW      [SHLWAPI.@]
    990  */
    991 BOOL WINAPI PathFileExistsW(LPCWSTR lpszPath) 
    992 {
    993         TRACE("%s\n",debugstr_w(lpszPath));
    994         return  (GetFileAttributesW(lpszPath)!=-1);
    995 }
    996 
    997 /*************************************************************************
    998  * PathMatchSingleMaskA [internal]
    999  * 
     983BOOL WINAPI PathFileExistsA(LPCSTR lpszPath)
     984{
     985    TRACE("%s\n",lpszPath);
     986    return  (GetFileAttributesA(lpszPath)!=-1);
     987}
     988
     989/*************************************************************************
     990 * PathFileExistsW  [SHLWAPI.@]
     991 */
     992BOOL WINAPI PathFileExistsW(LPCWSTR lpszPath)
     993{
     994    TRACE("%s\n",debugstr_w(lpszPath));
     995    return  (GetFileAttributesW(lpszPath)!=-1);
     996}
     997
     998/*************************************************************************
     999 * PathMatchSingleMaskA [internal]
     1000 *
    10001001 * NOTES
    10011002 *     internal (used by PathMatchSpec)
    … …  
    10031004static BOOL PathMatchSingleMaskA(LPCSTR name, LPCSTR mask)
    10041005{
    1005         while (*name && *mask && *mask!=';')
    1006         {
    1007           if (*mask=='*')
    1008           {
    1009             do
    1010             {
    1011               if (PathMatchSingleMaskA(name,mask+1)) return 1;  /* try substrings */
    1012             } while (*name++);
    1013             return 0;
    1014           }
    1015           if (toupper(*mask)!=toupper(*name) && *mask!='?') return 0;
    1016           name = CharNextA(name);
    1017           mask = CharNextA(mask);
    1018         }
    1019         if (!*name)
    1020         {
    1021           while (*mask=='*') mask++;
    1022           if (!*mask || *mask==';') return 1;
    1023         }
    1024         return 0;
    1025 }
    1026 
    1027 /*************************************************************************
    1028  * PathMatchSingleMaskW [internal]
     1006    while (*name && *mask && *mask!=';')
     1007    {
     1008      if (*mask=='*')
     1009      {
     1010        do
     1011        {
     1012          if (PathMatchSingleMaskA(name,mask+1)) return 1;  /* try substrings */
     1013        } while (*name++);
     1014        return 0;
     1015      }
     1016      if (toupper(*mask)!=toupper(*name) && *mask!='?') return 0;
     1017      name = CharNextA(name);
     1018      mask = CharNextA(mask);
     1019    }
     1020    if (!*name)
     1021    {
     1022      while (*mask=='*') mask++;
     1023      if (!*mask || *mask==';') return 1;
     1024    }
     1025    return 0;
     1026}
     1027
     1028/*************************************************************************
     1029 * PathMatchSingleMaskW [internal]
    10291030 */
    10301031static BOOL PathMatchSingleMaskW(LPCWSTR name, LPCWSTR mask)
    10311032{
    1032         while (*name && *mask && *mask!=';')
    1033         {
    1034           if (*mask=='*')
    1035           {
    1036             do
    1037             {
    1038               if (PathMatchSingleMaskW(name,mask+1)) return 1;  /* try substrings */
    1039             } while (*name++);
    1040             return 0;
    1041           }
    1042           if (toupperW(*mask)!=toupperW(*name) && *mask!='?') return 0;
    1043           name = CharNextW(name);
    1044           mask = CharNextW(mask);
    1045         }
    1046         if (!*name)
    1047         {
    1048           while (*mask=='*') mask++;
    1049           if (!*mask || *mask==';') return 1;
    1050         }
    1051         return 0;
    1052 }
    1053 /*************************************************************************
    1054  * PathMatchSpecA       [SHLWAPI.@]
    1055  * 
     1033    while (*name && *mask && *mask!=';')
     1034    {
     1035      if (*mask=='*')
     1036      {
     1037        do
     1038        {
     1039          if (PathMatchSingleMaskW(name,mask+1)) return 1;  /* try substrings */
     1040        } while (*name++);
     1041        return 0;
     1042      }
     1043      if (toupperW(*mask)!=toupperW(*name) && *mask!='?') return 0;
     1044      name = CharNextW(name);
     1045      mask = CharNextW(mask);
     1046    }
     1047    if (!*name)
     1048    {
     1049      while (*mask=='*') mask++;
     1050      if (!*mask || *mask==';') return 1;
     1051    }
     1052    return 0;
     1053}
     1054/*************************************************************************
     1055 * PathMatchSpecA   [SHLWAPI.@]
     1056 *
    10561057 * NOTES
    10571058 *     used from COMDLG32
    10581059 */
    1059 BOOL WINAPI PathMatchSpecA(LPCSTR name, LPCSTR mask) 
    1060 {
    1061         TRACE("%s %s\n",name,mask);
    1062 
    1063         if (!lstrcmpA( mask, "*.*" )) return 1;   /* we don't require a period */
    1064 
    1065         while (*mask)
    1066         {
    1067           if (PathMatchSingleMaskA(name,mask)) return 1;    /* helper function */
    1068           while (*mask && *mask!=';') mask = CharNextA(mask);
    1069           if (*mask==';')
    1070           {
    1071             mask++;
    1072             while (*mask==' ') mask++;      /*  masks may be separated by "; " */
    1073           }
    1074         }
    1075         return 0;
    1076 }
    1077 
    1078 /*************************************************************************
    1079  * PathMatchSpecW       [SHLWAPI.@]
    1080  */
    1081 BOOL WINAPI PathMatchSpecW(LPCWSTR name, LPCWSTR mask) 
     1060BOOL WINAPI PathMatchSpecA(LPCSTR name, LPCSTR mask)
     1061{
     1062    TRACE("%s %s\n",name,mask);
     1063
     1064    if (!lstrcmpA( mask, "*.*" )) return 1;   /* we don't require a period */
     1065
     1066    while (*mask)
     1067    {
     1068      if (PathMatchSingleMaskA(name,mask)) return 1;    /* helper function */
     1069      while (*mask && *mask!=';') mask = CharNextA(mask);
     1070      if (*mask==';')
     1071      {
     1072        mask++;
     1073        while (*mask==' ') mask++;      /*  masks may be separated by "; " */
     1074      }
     1075    }
     1076    return 0;
     1077}
     1078
     1079/*************************************************************************
     1080 * PathMatchSpecW   [SHLWAPI.@]
     1081 */
     1082BOOL WINAPI PathMatchSpecW(LPCWSTR name, LPCWSTR mask)
    10821083{
    10831084    static const WCHAR stemp[] = { '*','.','*',0 };
    1084         TRACE("%s %s\n",debugstr_w(name),debugstr_w(mask));
    1085 
    1086         if (!lstrcmpW( mask, stemp )) return 1;   /* we don't require a period */
    1087 
    1088         while (*mask)
    1089         {
    1090           if (PathMatchSingleMaskW(name,mask)) return 1;    /* helper function */
    1091           while (*mask && *mask!=';') mask = CharNextW(mask);
    1092           if (*mask==';')
    1093           {
    1094             mask++;
    1095             while (*mask==' ') mask++;       /* masks may be separated by "; " */
    1096           }
    1097         }
    1098         return 0;
    1099 }
    1100 
    1101 /*************************************************************************
    1102  * PathIsSameRootA      [SHLWAPI.@]
     1085    TRACE("%s %s\n",debugstr_w(name),debugstr_w(mask));
     1086
     1087    if (!lstrcmpW( mask, stemp )) return 1;   /* we don't require a period */
     1088
     1089    while (*mask)
     1090    {
     1091      if (PathMatchSingleMaskW(name,mask)) return 1;    /* helper function */
     1092      while (*mask && *mask!=';') mask = CharNextW(mask);
     1093      if (*mask==';')
     1094      {
     1095        mask++;
     1096        while (*mask==' ') mask++;       /* masks may be separated by "; " */
     1097      }
     1098    }
     1099    return 0;
     1100}
     1101
     1102/*************************************************************************
     1103 * PathIsSameRootA  [SHLWAPI.@]
    11031104 *
    11041105 * FIXME
    … …  
    11071108BOOL WINAPI PathIsSameRootA(LPCSTR lpszPath1, LPCSTR lpszPath2)
    11081109{
    1109         TRACE("%s %s\n", lpszPath1, lpszPath2);
    1110        
    1111         if (PathIsRelativeA(lpszPath1) || PathIsRelativeA(lpszPath2)) return FALSE;
    1112 
    1113         /* usual path */
    1114         if ( toupper(lpszPath1[0])==toupper(lpszPath2[0]) &&
    1115              lpszPath1[1]==':' && lpszPath2[1]==':' &&
    1116              lpszPath1[2]=='\\' && lpszPath2[2]=='\\')
    1117           return TRUE;
    1118 
    1119         /* UNC */
    1120         if (lpszPath1[0]=='\\' && lpszPath2[0]=='\\' &&
    1121             lpszPath1[1]=='\\' && lpszPath2[1]=='\\')
    1122         {
    1123           int pos=2, bsfound=0;
    1124           while (lpszPath1[pos] && lpszPath2[pos] &&
    1125                 (lpszPath1[pos] == lpszPath2[pos]))
    1126           {
    1127             if (lpszPath1[pos]=='\\') bsfound++;
    1128             if (bsfound == 2) return TRUE;
    1129             pos++; /* fixme: use CharNext*/
    1130           }
    1131           return (lpszPath1[pos] == lpszPath2[pos]);
    1132         }
    1133         return FALSE;
    1134 }
    1135 
    1136 /*************************************************************************
    1137  * PathIsSameRootW      [SHLWAPI.@]
     1110    TRACE("%s %s\n", lpszPath1, lpszPath2);
     1111
     1112    if (PathIsRelativeA(lpszPath1) || PathIsRelativeA(lpszPath2)) return FALSE;
     1113
     1114    /* usual path */
     1115    if ( toupper(lpszPath1[0])==toupper(lpszPath2[0]) &&
     1116         lpszPath1[1]==':' && lpszPath2[1]==':' &&
     1117         lpszPath1[2]=='\\' && lpszPath2[2]=='\\')
     1118      return TRUE;
     1119
     1120    /* UNC */
     1121    if (lpszPath1[0]=='\\' && lpszPath2[0]=='\\' &&
     1122        lpszPath1[1]=='\\' && lpszPath2[1]=='\\')
     1123    {
     1124      int pos=2, bsfound=0;
     1125      while (lpszPath1[pos] && lpszPath2[pos] &&
     1126            (lpszPath1[pos] == lpszPath2[pos]))
     1127      {
     1128        if (lpszPath1[pos]=='\\') bsfound++;
     1129        if (bsfound == 2) return TRUE;
     1130        pos++; /* fixme: use CharNext*/
     1131      }
     1132      return (lpszPath1[pos] == lpszPath2[pos]);
     1133    }
     1134    return FALSE;
     1135}
     1136
     1137/*************************************************************************
     1138 * PathIsSameRootW  [SHLWAPI.@]
    11381139 */
    11391140BOOL WINAPI PathIsSameRootW(LPCWSTR lpszPath1, LPCWSTR lpszPath2)
    11401141{
    1141         TRACE("%s %s\n", debugstr_w(lpszPath1), debugstr_w(lpszPath2));
    1142        
    1143         if (PathIsRelativeW(lpszPath1) || PathIsRelativeW(lpszPath2)) return FALSE;
    1144 
    1145         /* usual path */
    1146         if ( toupperW(lpszPath1[0])==toupperW(lpszPath2[0]) &&
    1147              lpszPath1[1]==':' && lpszPath2[1]==':' &&
    1148              lpszPath1[2]=='\\' && lpszPath2[2]=='\\')
    1149           return TRUE;
    1150 
    1151         /* UNC */
    1152         if (lpszPath1[0]=='\\' && lpszPath2[0]=='\\' &&
    1153             lpszPath1[1]=='\\' && lpszPath2[1]=='\\')
    1154         {
    1155           int pos=2, bsfound=0;
    1156           while (lpszPath1[pos] && lpszPath2[pos] &&
    1157                 (lpszPath1[pos] == lpszPath2[pos]))
    1158           {
    1159             if (lpszPath1[pos]=='\\') bsfound++;
    1160             if (bsfound == 2) return TRUE;
    1161             pos++;/* fixme: use CharNext*/
    1162           }
    1163           return (lpszPath1[pos] == lpszPath2[pos]);
    1164         }
    1165         return FALSE;
     1142    TRACE("%s %s\n", debugstr_w(lpszPath1), debugstr_w(lpszPath2));
     1143
     1144    if (PathIsRelativeW(lpszPath1) || PathIsRelativeW(lpszPath2)) return FALSE;
     1145
     1146    /* usual path */
     1147    if ( toupperW(lpszPath1[0])==toupperW(lpszPath2[0]) &&
     1148         lpszPath1[1]==':' && lpszPath2[1]==':' &&
     1149         lpszPath1[2]=='\\' && lpszPath2[2]=='\\')
     1150      return TRUE;
     1151
     1152    /* UNC */
     1153    if (lpszPath1[0]=='\\' && lpszPath2[0]=='\\' &&
     1154        lpszPath1[1]=='\\' && lpszPath2[1]=='\\')
     1155    {
     1156      int pos=2, bsfound=0;
     1157      while (lpszPath1[pos] && lpszPath2[pos] &&
     1158            (lpszPath1[pos] == lpszPath2[pos]))
     1159      {
     1160        if (lpszPath1[pos]=='\\') bsfound++;
     1161        if (bsfound == 2) return TRUE;
     1162        pos++;/* fixme: use CharNext*/
     1163      }
     1164      return (lpszPath1[pos] == lpszPath2[pos]);
     1165    }
     1166    return FALSE;
    11661167}
    11671168
    … …  
    11791180  // DWORD dwUnknown = SHREG_xxx; // 0x18
    11801181  // return SHLWAPI_1(lpstrPath, &dwUnknown);
    1181  
    1182  
    1183         LPSTR lpstrRes;
    1184         int iSize, i=0;
    1185         static LPSTR SupportedProtocol[] =
    1186           {"http","https","ftp","gopher","file","mailto",NULL};
    1187 
    1188         if(!lpstrPath) return FALSE;
    1189 
    1190         /* get protocol        */
    1191         lpstrRes = strchr(lpstrPath,':');
    1192         if(!lpstrRes) return FALSE;
    1193         iSize = lpstrRes - lpstrPath;
    1194 
    1195         while(SupportedProtocol[i])
    1196         {
    1197           if (iSize == strlen(SupportedProtocol[i]))
    1198             if(!strncasecmp(lpstrPath, SupportedProtocol[i], iSize))
    1199               return TRUE;
    1200           i++;
    1201         }
    1202 
    1203         return FALSE;
    1204 } 
     1182
     1183
     1184    LPSTR lpstrRes;
     1185    int iSize, i=0;
     1186    static LPSTR SupportedProtocol[] =
     1187      {"http","https","ftp","gopher","file","mailto",NULL};
     1188
     1189    if(!lpstrPath) return FALSE;
     1190
     1191    /* get protocol        */
     1192    lpstrRes = strchr(lpstrPath,':');
     1193    if(!lpstrRes) return FALSE;
     1194    iSize = lpstrRes - lpstrPath;
     1195
     1196    while(SupportedProtocol[i])
     1197    {
     1198      if (iSize == strlen(SupportedProtocol[i]))
     1199        if(!strncasecmp(lpstrPath, SupportedProtocol[i], iSize))
     1200          return TRUE;
     1201      i++;
     1202    }
     1203
     1204    return FALSE;
     1205}
    12051206
    12061207/*************************************************************************
    … …  
    12091210BOOL WINAPI PathIsURLW(LPCWSTR lpstrPath)
    12101211{
    1211         LPWSTR lpstrRes;
    1212         int iSize, i=0;
    1213         static WCHAR SupportedProtocol[7][7] =
    1214           {{'h','t','t','p','\0'},{'h','t','t','p','s','\0'},{'f','t','p','\0'},
    1215           {'g','o','p','h','e','r','\0'},{'f','i','l','e','\0'},
    1216           {'m','a','i','l','t','o','\0'},{0}};
    1217 
    1218         if(!lpstrPath) return FALSE;
    1219 
    1220         /* get protocol        */
    1221         lpstrRes = strchrW(lpstrPath,':');
    1222         if(!lpstrRes) return FALSE;
    1223         iSize = lpstrRes - lpstrPath;
    1224 
    1225         while(SupportedProtocol[i])
    1226         {
    1227           if (iSize == strlenW(SupportedProtocol[i]))
    1228             if(!strncmpiW(lpstrPath, SupportedProtocol[i], iSize))
    1229               return TRUE;
    1230           i++;
    1231         }
    1232 
    1233         return FALSE;
    1234 } 
    1235 
    1236 
    1237 /*************************************************************************
    1238  *      PathIsContentTypeA   [SHLWAPI.@]
     1212    LPWSTR lpstrRes;
     1213    int iSize, i=0;
     1214    static WCHAR SupportedProtocol[7][7] =
     1215      {{'h','t','t','p','\0'},{'h','t','t','p','s','\0'},{'f','t','p','\0'},
     1216      {'g','o','p','h','e','r','\0'},{'f','i','l','e','\0'},
     1217      {'m','a','i','l','t','o','\0'},{0}};
     1218
     1219    if(!lpstrPath) return FALSE;
     1220
     1221    /* get protocol        */
     1222    lpstrRes = strchrW(lpstrPath,':');
     1223    if(!lpstrRes) return FALSE;
     1224    iSize = lpstrRes - lpstrPath;
     1225
     1226    while(SupportedProtocol[i])
     1227    {
     1228      if (iSize == strlenW(SupportedProtocol[i]))
     1229        if(!strncmpiW(lpstrPath, SupportedProtocol[i], iSize))
     1230          return TRUE;
     1231      i++;
     1232    }
     1233
     1234    return FALSE;
     1235}
     1236
     1237
     1238/*************************************************************************
     1239 *  PathIsContentTypeA   [SHLWAPI.@]
    12391240 */
    12401241BOOL WINAPI PathIsContentTypeA(LPCSTR pszPath, LPCSTR pszContentType)
    12411242{
    1242         FIXME("%s %s\n", pszPath, pszContentType);
    1243         return FALSE;
    1244 }
    1245 
    1246 /*************************************************************************
    1247  *      PathIsContentTypeW   [SHLWAPI.@]
     1243    FIXME("%s %s\n", pszPath, pszContentType);
     1244    return FALSE;
     1245}
     1246
     1247/*************************************************************************
     1248 *  PathIsContentTypeW   [SHLWAPI.@]
    12481249 */
    12491250BOOL WINAPI PathIsContentTypeW(LPCWSTR pszPath, LPCWSTR pszContentType)
    12501251{
    1251         FIXME("%s %s\n", debugstr_w(pszPath), debugstr_w(pszContentType));
    1252         return FALSE;
    1253 }
    1254 
    1255 /*************************************************************************
    1256  *      PathIsFileSpecA   [SHLWAPI.@]
     1252    FIXME("%s %s\n", debugstr_w(pszPath), debugstr_w(pszContentType));
     1253    return FALSE;
     1254}
     1255
     1256/*************************************************************************
     1257 *  PathIsFileSpecA   [SHLWAPI.@]
    12571258 */
    12581259BOOL WINAPI PathIsFileSpecA(LPCSTR pszPath)
    12591260{
    1260         FIXME("%s\n", pszPath);
    1261         return FALSE;
    1262 }
    1263 
    1264 /*************************************************************************
    1265  *      PathIsFileSpecW   [SHLWAPI.@]
     1261    FIXME("%s\n", pszPath);
     1262    return FALSE;
     1263}
     1264
     1265/*************************************************************************
     1266 *  PathIsFileSpecW   [SHLWAPI.@]
    12661267 */
    12671268BOOL WINAPI PathIsFileSpecW(LPCWSTR pszPath)
    12681269{
    1269         FIXME("%s\n", debugstr_w(pszPath));
    1270         return FALSE;
    1271 }
    1272 
    1273 /*************************************************************************
    1274  *      PathIsPrefixA   [SHLWAPI.@]
     1270    FIXME("%s\n", debugstr_w(pszPath));
     1271    return FALSE;
     1272}
     1273
     1274/*************************************************************************
     1275 *  PathIsPrefixA   [SHLWAPI.@]
    12751276 */
    12761277BOOL WINAPI PathIsPrefixA(LPCSTR pszPrefix, LPCSTR pszPath)
    12771278{
    1278         FIXME("%s %s\n", pszPrefix, pszPath);
    1279         return FALSE;
    1280 }
    1281 
    1282 /*************************************************************************
    1283  *      PathIsPrefixW   [SHLWAPI.@]
     1279    FIXME("%s %s\n", pszPrefix, pszPath);
     1280    return FALSE;
     1281}
     1282
     1283/*************************************************************************
     1284 *  PathIsPrefixW   [SHLWAPI.@]
    12841285 */
    12851286BOOL WINAPI PathIsPrefixW(LPCWSTR pszPrefix, LPCWSTR pszPath)
    12861287{
    1287         FIXME("%s %s\n", debugstr_w(pszPrefix), debugstr_w(pszPath));
    1288         return FALSE;
    1289 }
    1290 
    1291 /*************************************************************************
    1292  *      PathIsSystemFolderA   [SHLWAPI.@]
     1288    FIXME("%s %s\n", debugstr_w(pszPrefix), debugstr_w(pszPath));
     1289    return FALSE;
     1290}
     1291
     1292/*************************************************************************
     1293 *  PathIsSystemFolderA   [SHLWAPI.@]
    12931294 */
    12941295BOOL WINAPI PathIsSystemFolderA(LPCSTR pszPath, DWORD dwAttrb)
    12951296{
    1296         FIXME("%s 0x%08lx\n", pszPath, dwAttrb);
    1297         return FALSE;
    1298 }
    1299 
    1300 /*************************************************************************
    1301  *      PathIsSystemFolderW   [SHLWAPI.@]
     1297    FIXME("%s 0x%08lx\n", pszPath, dwAttrb);
     1298    return FALSE;
     1299}
     1300
     1301/*************************************************************************
     1302 *  PathIsSystemFolderW   [SHLWAPI.@]
    13021303 */
    13031304BOOL WINAPI PathIsSystemFolderW(LPCWSTR pszPath, DWORD dwAttrb)
    13041305{
    1305         FIXME("%s 0x%08lx\n", debugstr_w(pszPath), dwAttrb);
    1306         return FALSE;
    1307 }
    1308 
    1309 /*************************************************************************
    1310  *      PathIsUNCServerA   [SHLWAPI.@]
     1306    FIXME("%s 0x%08lx\n", debugstr_w(pszPath), dwAttrb);
     1307    return FALSE;
     1308}
     1309
     1310/*************************************************************************
     1311 *  PathIsUNCServerA   [SHLWAPI.@]
    13111312 */
    13121313BOOL WINAPI PathIsUNCServerA(
    1313         LPCSTR pszPath)
    1314 {
    1315         FIXME("%s\n", pszPath);
    1316         return FALSE;
    1317 }
    1318 
    1319 /*************************************************************************
    1320  *      PathIsUNCServerW   [SHLWAPI.@]
     1314    LPCSTR pszPath)
     1315{
     1316    FIXME("%s\n", pszPath);
     1317    return FALSE;
     1318}
     1319
     1320/*************************************************************************
     1321 *  PathIsUNCServerW   [SHLWAPI.@]
    13211322 */
    13221323BOOL WINAPI PathIsUNCServerW(
    1323         LPCWSTR pszPath)
    1324 {
    1325         FIXME("%s\n", debugstr_w(pszPath));
    1326         return FALSE;
    1327 }
    1328 
    1329 /*************************************************************************
    1330  *      PathIsUNCServerShareA   [SHLWAPI.@]
     1324    LPCWSTR pszPath)
     1325{
     1326    FIXME("%s\n", debugstr_w(pszPath));
     1327    return FALSE;
     1328}
     1329
     1330/*************************************************************************
     1331 *  PathIsUNCServerShareA   [SHLWAPI.@]
    13311332 */
    13321333BOOL WINAPI PathIsUNCServerShareA(
    1333         LPCSTR pszPath)
    1334 {
    1335         FIXME("%s\n", pszPath);
    1336         return FALSE;
    1337 }
    1338 
    1339 /*************************************************************************
    1340  *      PathIsUNCServerShareW   [SHLWAPI.@]
     1334    LPCSTR pszPath)
     1335{
     1336    FIXME("%s\n", pszPath);
     1337    return FALSE;
     1338}
     1339
     1340/*************************************************************************
     1341 *  PathIsUNCServerShareW   [SHLWAPI.@]
    13411342 */
    13421343BOOL WINAPI PathIsUNCServerShareW(
    1343         LPCWSTR pszPath)
    1344 {
    1345         FIXME("%s\n", debugstr_w(pszPath));
    1346         return FALSE;
     1344    LPCWSTR pszPath)
     1345{
     1346    FIXME("%s\n", debugstr_w(pszPath));
     1347    return FALSE;
    13471348}
    13481349
    … …  
    13531354 *   returnvalue, use CharNext
    13541355 */
    1355  
     1356
    13561357BOOL WINAPI PathCanonicalizeA(LPSTR pszBuf, LPCSTR pszPath)
    13571358{
    1358         int OffsetMin = 0, OffsetSrc = 0, OffsetDst = 0, LenSrc = strlen(pszPath);
    1359         BOOL bModifyed = FALSE;
    1360 
    1361         TRACE("%p %s\n", pszBuf, pszPath);
    1362        
    1363         pszBuf[OffsetDst]='\0';
    1364 
    1365         /* keep the root of the path */
    1366         if( LenSrc && (pszPath[OffsetSrc]=='\\'))
    1367         {
    1368           pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
    1369         }
    1370         else if ( (LenSrc >= 2) && (pszPath[OffsetSrc+1] == ':'))
    1371         {
    1372           pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
    1373           pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
    1374           if (LenSrc && (pszPath[OffsetSrc] == '\\'))
    1375           {
    1376             pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
    1377             if (LenSrc == 1 && pszPath[OffsetSrc]=='.')
    1378             {
    1379               /* C:\. */
    1380               OffsetSrc++; LenSrc--; bModifyed = TRUE;
    1381             }
    1382             else if (LenSrc == 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='.')
    1383             {
    1384               /* C:\.. */
    1385               OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
    1386             }
     1359    int OffsetMin = 0, OffsetSrc = 0, OffsetDst = 0, LenSrc = strlen(pszPath);
     1360    BOOL bModifyed = FALSE;
     1361
     1362    TRACE("%p %s\n", pszBuf, pszPath);
     1363
     1364    pszBuf[OffsetDst]='\0';
     1365
     1366    /* keep the root of the path */
     1367    if( LenSrc && (pszPath[OffsetSrc]=='\\'))
     1368    {
     1369      pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
     1370    }
     1371    else if ( (LenSrc >= 2) && (pszPath[OffsetSrc+1] == ':'))
     1372    {
     1373      pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
     1374      pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
     1375      if (LenSrc && (pszPath[OffsetSrc] == '\\'))
     1376      {
     1377        pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
     1378        if (LenSrc == 1 && pszPath[OffsetSrc]=='.')
     1379        {
     1380          /* C:\. */
     1381          OffsetSrc++; LenSrc--; bModifyed = TRUE;
     1382        }
     1383        else if (LenSrc == 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='.')
     1384        {
     1385          /* C:\.. */
     1386          OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
     1387        }
    13871388          }
    1388         }
    1389        
    1390         /* ".\" at the beginning of the path */
    1391         if (LenSrc >= 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='\\')
    1392         {
    1393           OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
    1394         }
    1395        
    1396         while ( LenSrc )
    1397         {
    1398           if((LenSrc>=3) && (pszPath[OffsetSrc]=='\\') && (pszPath[OffsetSrc+1]=='.') && (pszPath[OffsetSrc+2]=='.'))
    1399           {
    1400             /* "\.." found, go one deeper */
    1401             while((OffsetDst > OffsetMin) && (pszBuf[OffsetDst]!='\\')) OffsetDst--;
    1402             OffsetSrc += 3; LenSrc -= 3; bModifyed = TRUE;
    1403             if(OffsetDst == OffsetMin && pszPath[OffsetSrc]=='\\') OffsetSrc++;
    1404             pszBuf[OffsetDst] = '\0';                   /* important for \..\.. */
    1405           }
    1406           else if(LenSrc>=2 && pszPath[OffsetSrc]=='\\' && pszPath[OffsetSrc+1]=='.' )
    1407           {
    1408             /* "\." found, skip it */
    1409             OffsetSrc += 2; LenSrc-=2; bModifyed = TRUE;
    1410           }
    1411           else
    1412           {
    1413             pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; LenSrc--;
    1414           }
    1415         }
    1416         pszBuf[OffsetDst] = '\0';
    1417         TRACE("-- %s %u\n", pszBuf, bModifyed);
    1418         return bModifyed;
     1389    }
     1390
     1391    /* ".\" at the beginning of the path */
     1392    if (LenSrc >= 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='\\')
     1393    {
     1394      OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
     1395    }
     1396
     1397    while ( LenSrc )
     1398    {
     1399      if((LenSrc>=3) && (pszPath[OffsetSrc]=='\\') && (pszPath[OffsetSrc+1]=='.') && (pszPath[OffsetSrc+2]=='.'))
     1400      {
     1401        /* "\.." found, go one deeper */
     1402        while((OffsetDst > OffsetMin) && (pszBuf[OffsetDst]!='\\')) OffsetDst--;
     1403        OffsetSrc += 3; LenSrc -= 3; bModifyed = TRUE;
     1404        if(OffsetDst == OffsetMin && pszPath[OffsetSrc]=='\\') OffsetSrc++;
     1405        pszBuf[OffsetDst] = '\0';           /* important for \..\.. */
     1406      }
     1407      else if(LenSrc>=2 && pszPath[OffsetSrc]=='\\' && pszPath[OffsetSrc+1]=='.' )
     1408      {
     1409        /* "\." found, skip it */
     1410        OffsetSrc += 2; LenSrc-=2; bModifyed = TRUE;
     1411      }
     1412      else
     1413      {
     1414        pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; LenSrc--;
     1415      }
     1416    }
     1417    pszBuf[OffsetDst] = '\0';
     1418    TRACE("-- %s %u\n", pszBuf, bModifyed);
     1419    return bModifyed;
    14191420}
    14201421
    … …  
    14281429BOOL WINAPI PathCanonicalizeW(LPWSTR pszBuf, LPCWSTR pszPath)
    14291430{
    1430         int OffsetMin = 0, OffsetSrc = 0, OffsetDst = 0, LenSrc = strlenW(pszPath);
    1431         BOOL bModifyed = FALSE;
    1432 
    1433         TRACE("%p %s\n", pszBuf, debugstr_w(pszPath));
    1434        
    1435         pszBuf[OffsetDst]='\0';
    1436 
    1437         /* keep the root of the path */
    1438         if( LenSrc && (pszPath[OffsetSrc]=='\\'))
    1439         {
    1440           pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
    1441         }
    1442         else if ( (LenSrc >= 2) && (pszPath[OffsetSrc+1] == ':'))
    1443         {
    1444           pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
    1445           pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
    1446           if (LenSrc && (pszPath[OffsetSrc] == '\\'))
    1447           {
    1448             pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
    1449             if (LenSrc == 1 && pszPath[OffsetSrc]=='.')
    1450             {
    1451               /* C:\. */
    1452               OffsetSrc++; LenSrc--; bModifyed = TRUE;
    1453             }
    1454             else if (LenSrc == 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='.')
    1455             {
    1456               /* C:\.. */
    1457               OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
    1458             }
     1431    int OffsetMin = 0, OffsetSrc = 0, OffsetDst = 0, LenSrc = strlenW(pszPath);
     1432    BOOL bModifyed = FALSE;
     1433
     1434    TRACE("%p %s\n", pszBuf, debugstr_w(pszPath));
     1435
     1436    pszBuf[OffsetDst]='\0';
     1437
     1438    /* keep the root of the path */
     1439    if( LenSrc && (pszPath[OffsetSrc]=='\\'))
     1440    {
     1441      pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
     1442    }
     1443    else if ( (LenSrc >= 2) && (pszPath[OffsetSrc+1] == ':'))
     1444    {
     1445      pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
     1446      pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
     1447      if (LenSrc && (pszPath[OffsetSrc] == '\\'))
     1448      {
     1449        pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
     1450        if (LenSrc == 1 && pszPath[OffsetSrc]=='.')
     1451        {
     1452          /* C:\. */
     1453          OffsetSrc++; LenSrc--; bModifyed = TRUE;
     1454        }
     1455        else if (LenSrc == 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='.')
     1456        {
     1457          /* C:\.. */
     1458          OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
     1459        }
    14591460          }
    1460         }
    1461        
    1462         /* ".\" at the beginning of the path */
    1463         if (LenSrc >= 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='\\')
    1464         {
    1465           OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
    1466         }
    1467        
    1468         while ( LenSrc )
    1469         {
    1470           if((LenSrc>=3) && (pszPath[OffsetSrc]=='\\') && (pszPath[OffsetSrc+1]=='.') && (pszPath[OffsetSrc+2]=='.'))
    1471           {
    1472             /* "\.." found, go one deeper */
    1473             while((OffsetDst > OffsetMin) && (pszBuf[OffsetDst]!='\\')) OffsetDst--;
    1474             OffsetSrc += 3; LenSrc -= 3; bModifyed = TRUE;
    1475             if(OffsetDst == OffsetMin && pszPath[OffsetSrc]=='\\') OffsetSrc++;
    1476             pszBuf[OffsetDst] = '\0';                   /* important for \..\.. */
    1477           }
    1478           else if(LenSrc>=2 && pszPath[OffsetSrc]=='\\' && pszPath[OffsetSrc+1]=='.' )
    1479           {
    1480             /* "\." found, skip it */
    1481             OffsetSrc += 2; LenSrc-=2; bModifyed = TRUE;
    1482           }
    1483           else
    1484           {
    1485             pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; LenSrc--;
    1486           }
    1487         }
    1488         pszBuf[OffsetDst] = '\0';
    1489         TRACE("-- %s %u\n", debugstr_w(pszBuf), bModifyed);
    1490         return bModifyed;
     1461    }
     1462
     1463    /* ".\" at the beginning of the path */
     1464    if (LenSrc >= 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='\\')
     1465    {
     1466      OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
     1467    }
     1468
     1469    while ( LenSrc )
     1470    {
     1471      if((LenSrc>=3) && (pszPath[OffsetSrc]=='\\') && (pszPath[OffsetSrc+1]=='.') && (pszPath[OffsetSrc+2]=='.'))
     1472      {
     1473        /* "\.." found, go one deeper */
     1474        while((OffsetDst > OffsetMin) && (pszBuf[OffsetDst]!='\\')) OffsetDst--;
     1475        OffsetSrc += 3; LenSrc -= 3; bModifyed = TRUE;
     1476        if(OffsetDst == OffsetMin && pszPath[OffsetSrc]=='\\') OffsetSrc++;
     1477        pszBuf[OffsetDst] = '\0';           /* important for \..\.. */
     1478      }
     1479      else if(LenSrc>=2 && pszPath[OffsetSrc]=='\\' && pszPath[OffsetSrc+1]=='.' )
     1480      {
     1481        /* "\." found, skip it */
     1482        OffsetSrc += 2; LenSrc-=2; bModifyed = TRUE;
     1483      }
     1484      else
     1485      {
     1486        pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; LenSrc--;
     1487      }
     1488    }
     1489    pszBuf[OffsetDst] = '\0';
     1490    TRACE("-- %s %u\n", debugstr_w(pszBuf), bModifyed);
     1491    return bModifyed;
    14911492}
    14921493
    … …  
    14961497 * NOTES
    14971498 * special cases:
    1498  *      ""              null
    1499  *      aa              "" (pointer to traling NULL)
    1500  *      aa\             "" (pointer to traling NULL)
    1501  *      aa\\            "" (pointer to traling NULL)
    1502  *      aa\\bb          bb
    1503  *      aa\\\bb         \bb
    1504  *      c:\aa\          "aa\"
    1505  *      \\aa            aa
    1506  *      \\aa\b          aa\b
     1499 *  ""              null
     1500 *  aa              "" (pointer to traling NULL)
     1501 *  aa\             "" (pointer to traling NULL)
     1502 *  aa\\            "" (pointer to traling NULL)
     1503 *  aa\\bb          bb
     1504 *  aa\\\bb         \bb
     1505 *  c:\aa\          "aa\"
     1506 *  \\aa            aa
     1507 *  \\aa\b          aa\b
    15071508*/
    15081509LPSTR WINAPI PathFindNextComponentA(LPCSTR pszPath)
    15091510{
    1510         LPSTR pos;
    1511 
    1512         TRACE("%s\n", pszPath);
    1513 
    1514         if(!pszPath || !*pszPath) return NULL;
    1515         if(!(pos = StrChrA(pszPath, '\\')))
    1516           return (LPSTR) pszPath + strlen(pszPath);
    1517         pos++;
    1518         if(pos[0] == '\\') pos++;
    1519         return pos;
     1511    LPSTR pos;
     1512
     1513    TRACE("%s\n", pszPath);
     1514
     1515    if(!pszPath || !*pszPath) return NULL;
     1516    if(!(pos = StrChrA(pszPath, '\\')))
     1517      return (LPSTR) pszPath + strlen(pszPath);
     1518    pos++;
     1519    if(pos[0] == '\\') pos++;
     1520    return pos;
    15201521}
    15211522
    … …  
    15251526LPWSTR WINAPI PathFindNextComponentW(LPCWSTR pszPath)
    15261527{
    1527         LPWSTR pos;
    1528 
    1529         TRACE("%s\n", debugstr_w(pszPath));
    1530        
    1531         if(!pszPath || !*pszPath) return NULL;
    1532         if (!(pos = StrChrW(pszPath, '\\')))
    1533           return (LPWSTR) pszPath + strlenW(pszPath);
    1534         pos++;
    1535         if(pos[0] == '\\') pos++;
    1536         return pos;
     1528    LPWSTR pos;
     1529
     1530    TRACE("%s\n", debugstr_w(pszPath));
     1531
     1532    if(!pszPath || !*pszPath) return NULL;
     1533    if (!(pos = StrChrW(pszPath, '\\')))
     1534      return (LPWSTR) pszPath + strlenW(pszPath);
     1535    pos++;
     1536    if(pos[0] == '\\') pos++;
     1537    return pos;
    15371538}
    15381539
    … …  
    15431544 *  it adds never a dot
    15441545 */
    1545  
     1546
    15461547BOOL WINAPI PathAddExtensionA(
    1547         LPSTR  pszPath,
    1548         LPCSTR pszExtension)
    1549 {
    1550         if (*pszPath)
    1551         {
    1552           if (*(PathFindExtensionA(pszPath))) return FALSE;
    1553 
    1554           if (!pszExtension || *pszExtension=='\0')
    1555             strcat(pszPath, "exe");
    1556           else
    1557             strcat(pszPath, pszExtension);
    1558         }
    1559 
    1560         return TRUE;
    1561 }
    1562 
    1563 /*************************************************************************
    1564  *      PathAddExtensionW   [SHLWAPI.@]
     1548    LPSTR  pszPath,
     1549    LPCSTR pszExtension)
     1550{
     1551    if (*pszPath)
     1552    {
     1553      if (*(PathFindExtensionA(pszPath))) return FALSE;
     1554
     1555      if (!pszExtension || *pszExtension=='\0')
     1556        strcat(pszPath, "exe");
     1557      else
     1558        strcat(pszPath, pszExtension);
     1559    }
     1560
     1561    return TRUE;
     1562}
     1563
     1564/*************************************************************************
     1565 *  PathAddExtensionW   [SHLWAPI.@]
    15651566 */
    15661567BOOL WINAPI PathAddExtensionW(
    1567         LPWSTR  pszPath,
    1568         LPCWSTR pszExtension)
    1569 {
    1570         static const WCHAR ext[] = { 'e','x','e',0 };
    1571 
    1572         if (*pszPath)
    1573         {
    1574           if (*(PathFindExtensionW(pszPath))) return FALSE;
    1575 
    1576           if (!pszExtension || *pszExtension=='\0')
    1577             strcatW(pszPath, ext);
    1578           else
    1579             strcatW(pszPath, pszExtension);
    1580         }
    1581         return TRUE;
    1582 
    1583 }
    1584 
    1585 /*************************************************************************
    1586  *      PathMakePrettyA   [SHLWAPI.@]
     1568    LPWSTR  pszPath,
     1569    LPCWSTR pszExtension)
     1570{
     1571    static const WCHAR ext[] = { 'e','x','e',0 };
     1572
     1573    if (*pszPath)
     1574    {
     1575      if (*(PathFindExtensionW(pszPath))) return FALSE;
     1576
     1577      if (!pszExtension || *pszExtension=='\0')
     1578        strcatW(pszPath, ext);
     1579      else
     1580        strcatW(pszPath, pszExtension);
     1581    }
     1582    return TRUE;
     1583
     1584}
     1585
     1586/*************************************************************************
     1587 *  PathMakePrettyA   [SHLWAPI.@]
    15871588 */
    15881589BOOL WINAPI PathMakePrettyA(
    1589         LPSTR lpPath)
    1590 {
    1591         FIXME("%s\n", lpPath);
    1592         return TRUE;
    1593 }
    1594 
    1595 /*************************************************************************
    1596  *      PathMakePrettyW   [SHLWAPI.@]
     1590    LPSTR lpPath)
     1591{
     1592    FIXME("%s\n", lpPath);
     1593    return TRUE;
     1594}
     1595
     1596/*************************************************************************
     1597 *  PathMakePrettyW   [SHLWAPI.@]
    15971598 */
    15981599BOOL WINAPI PathMakePrettyW(
    1599         LPWSTR lpPath)
    1600 {
    1601         FIXME("%s\n", debugstr_w(lpPath));
    1602         return TRUE;
    1603 
    1604 }
    1605 
    1606 /*************************************************************************
    1607  *      PathCommonPrefixA   [SHLWAPI.@]
     1600    LPWSTR lpPath)
     1601{
     1602    FIXME("%s\n", debugstr_w(lpPath));
     1603    return TRUE;
     1604
     1605}
     1606
     1607/*************************************************************************
     1608 *  PathCommonPrefixA   [SHLWAPI.@]
    16081609 */
    16091610int WINAPI PathCommonPrefixA(
    1610         LPCSTR pszFile1,
    1611         LPCSTR pszFile2,
    1612         LPSTR achPath)
    1613 {
    1614         FIXME("%s %s %p\n", pszFile1, pszFile2, achPath);
    1615         return 0;
    1616 }
    1617 
    1618 /*************************************************************************
    1619  *      PathCommonPrefixW   [SHLWAPI.@]
     1611    LPCSTR pszFile1,
     1612    LPCSTR pszFile2,
     1613    LPSTR achPath)
     1614{
     1615    FIXME("%s %s %p\n", pszFile1, pszFile2, achPath);
     1616    return 0;
     1617}
     1618
     1619/*************************************************************************
     1620 *  PathCommonPrefixW   [SHLWAPI.@]
    16201621 */
    16211622int WINAPI PathCommonPrefixW(
    1622         LPCWSTR pszFile1,
    1623         LPCWSTR pszFile2,
    1624         LPWSTR achPath)
    1625 {
    1626         FIXME("%s %s %p\n", debugstr_w(pszFile1), debugstr_w(pszFile2),achPath );
    1627         return 0;
    1628 }
    1629 
    1630 /*************************************************************************
    1631  *      PathCompactPathA   [SHLWAPI.@]
     1623    LPCWSTR pszFile1,
     1624    LPCWSTR pszFile2,
     1625    LPWSTR achPath)
     1626{
     1627    FIXME("%s %s %p\n", debugstr_w(pszFile1), debugstr_w(pszFile2),achPath );
     1628    return 0;
     1629}
     1630
     1631/*************************************************************************
     1632 *  PathCompactPathA   [SHLWAPI.@]
    16321633 */
    16331634BOOL WINAPI PathCompactPathA(HDC hDC, LPSTR pszPath, UINT dx)
    16341635{
    1635         FIXME("0x%08x %s 0x%08x\n", hDC, pszPath, dx);
    1636         return FALSE;
    1637 }
    1638 
    1639 /*************************************************************************
    1640  *      PathCompactPathW   [SHLWAPI.@]
     1636    FIXME("0x%08x %s 0x%08x\n", hDC, pszPath, dx);
     1637    return FALSE;
     1638}
     1639
     1640/*************************************************************************
     1641 *  PathCompactPathW   [SHLWAPI.@]
    16411642 */
    16421643BOOL WINAPI PathCompactPathW(HDC hDC, LPWSTR pszPath, UINT dx)
    16431644{
    1644         FIXME("0x%08x %s 0x%08x\n", hDC, debugstr_w(pszPath), dx);
    1645         return FALSE;
    1646 }
    1647 
    1648 /*************************************************************************
    1649  *      PathGetCharTypeA   [SHLWAPI.@]
     1645    FIXME("0x%08x %s 0x%08x\n", hDC, debugstr_w(pszPath), dx);
     1646    return FALSE;
     1647}
     1648
     1649/*************************************************************************
     1650 *  PathGetCharTypeA   [SHLWAPI.@]
    16501651 */
    16511652UINT WINAPI PathGetCharTypeA(UCHAR ch)
    … …  
    16531654        UINT flags = 0;
    16541655
    1655         TRACE("%c\n", ch);
    1656 
    1657         /* We could use them in filenames, but this would confuse 'ls' */
    1658         if (iscntrl(ch))
    1659             return GCT_INVALID;
    1660         if ((ch == '*') || (ch=='?'))
    1661             return GCT_WILD;
    1662         if ((ch == '\\') || (ch=='/'))
    1663             return GCT_SEPARATOR;
    1664         flags = 0;
    1665         /* all normal characters, no lower case letters */
    1666         if ((ch > ' ') && (ch < 0x7f) && !islower(ch))
    1667             flags |= GCT_SHORTCHAR;
    1668         /* All other characters are valid in long filenames, even umlauts */
    1669         return flags | GCT_LFNCHAR;
    1670 }
    1671 
    1672 /*************************************************************************
    1673  *      PathGetCharTypeW   [SHLWAPI.@]
     1656    TRACE("%c\n", ch);
     1657
     1658    /* We could use them in filenames, but this would confuse 'ls' */
     1659    if (iscntrl(ch))
     1660        return GCT_INVALID;
     1661    if ((ch == '*') || (ch=='?'))
     1662        return GCT_WILD;
     1663    if ((ch == '\\') || (ch=='/'))
     1664        return GCT_SEPARATOR;
     1665    flags = 0;
     1666    /* all normal characters, no lower case letters */
     1667    if ((ch > ' ') && (ch < 0x7f) && !islower(ch))
     1668        flags |= GCT_SHORTCHAR;
     1669    /* All other characters are valid in long filenames, even umlauts */
     1670    return flags | GCT_LFNCHAR;
     1671}
     1672
     1673/*************************************************************************
     1674 *  PathGetCharTypeW   [SHLWAPI.@]
    16741675 */
    16751676UINT WINAPI PathGetCharTypeW(WCHAR ch)
    16761677{
    1677         FIXME("%c, using ascii version\n", ch);
    1678         return PathGetCharTypeA(ch);
    1679 }
    1680 
    1681 /*************************************************************************
    1682  *      PathMakeSystemFolderA   [SHLWAPI.@]
     1678    FIXME("%c, using ascii version\n", ch);
     1679    return PathGetCharTypeA(ch);
     1680}
     1681
     1682/*************************************************************************
     1683 *  PathMakeSystemFolderA   [SHLWAPI.@]
    16831684 */
    16841685BOOL WINAPI PathMakeSystemFolderA(LPCSTR pszPath)
    16851686{
    1686         FIXME("%s\n", pszPath);
    1687         return FALSE;
    1688 }
    1689 
    1690 /*************************************************************************
    1691  *      PathMakeSystemFolderW   [SHLWAPI.@]
     1687    FIXME("%s\n", pszPath);
     1688    return FALSE;
     1689}
     1690
     1691/*************************************************************************
     1692 *  PathMakeSystemFolderW   [SHLWAPI.@]
    16921693 */
    16931694BOOL WINAPI PathMakeSystemFolderW(LPCWSTR pszPath)
    16941695{
    1695         FIXME("%s\n", debugstr_w(pszPath));
    1696         return FALSE;
    1697 }
    1698 
    1699 /*************************************************************************
    1700  *      PathRenameExtensionA   [SHLWAPI.@]
     1696    FIXME("%s\n", debugstr_w(pszPath));
     1697    return FALSE;
     1698}
     1699
     1700/*************************************************************************
     1701 *  PathRenameExtensionA   [SHLWAPI.@]
    17011702 */
    17021703BOOL WINAPI PathRenameExtensionA(LPSTR pszPath, LPCSTR pszExt)
    17031704{
    1704         FIXME("%s %s\n", pszPath, pszExt);
    1705         return FALSE;
    1706 }
    1707 
    1708 /*************************************************************************
    1709  *      PathRenameExtensionW   [SHLWAPI.@]
     1705    FIXME("%s %s\n", pszPath, pszExt);
     1706    return FALSE;
     1707}
     1708
     1709/*************************************************************************
     1710 *  PathRenameExtensionW   [SHLWAPI.@]
    17101711 */
    17111712BOOL WINAPI PathRenameExtensionW(LPWSTR pszPath, LPCWSTR pszExt)
    17121713{
    1713         FIXME("%s %s\n", debugstr_w(pszPath), debugstr_w(pszExt));
    1714         return FALSE;
    1715 }
    1716 
    1717 /*************************************************************************
    1718  *      PathSearchAndQualifyA   [SHLWAPI.@]
     1714    FIXME("%s %s\n", debugstr_w(pszPath), debugstr_w(pszExt));
     1715    return FALSE;
     1716}
     1717
     1718/*************************************************************************
     1719 *  PathSearchAndQualifyA   [SHLWAPI.@]
    17191720 */
    17201721BOOL WINAPI PathSearchAndQualifyA(
    1721         LPCSTR pszPath,
    1722         LPSTR pszBuf,
    1723         UINT cchBuf)
    1724 {
    1725         FIXME("%s %s 0x%08x\n", pszPath, pszBuf, cchBuf);
    1726         return FALSE;
    1727 }
    1728 
    1729 /*************************************************************************
    1730  *      PathSearchAndQualifyW   [SHLWAPI.@]
     1722    LPCSTR pszPath,
     1723    LPSTR pszBuf,
     1724    UINT cchBuf)
     1725{
     1726    FIXME("%s %s 0x%08x\n", pszPath, pszBuf, cchBuf);
     1727    return FALSE;
     1728}
     1729
     1730/*************************************************************************
     1731 *  PathSearchAndQualifyW   [SHLWAPI.@]
    17311732 */
    17321733BOOL WINAPI PathSearchAndQualifyW(
    1733         LPCWSTR pszPath,
    1734         LPWSTR pszBuf,
    1735         UINT cchBuf)
    1736 {
    1737         FIXME("%s %s 0x%08x\n", debugstr_w(pszPath), debugstr_w(pszBuf), cchBuf);
    1738         return FALSE;
     1734    LPCWSTR pszPath,
     1735    LPWSTR pszBuf,
     1736    UINT cchBuf)
     1737{
     1738    FIXME("%s %s 0x%08x\n", debugstr_w(pszPath), debugstr_w(pszBuf), cchBuf);
     1739    return FALSE;
    17391740}
    17401741
    17411742#ifndef __WIN32OS2__
    17421743/*************************************************************************
    1743  *      PathSkipRootA   [SHLWAPI.@]
     1744 *  PathSkipRootA   [SHLWAPI.@]
    17441745 */
    17451746LPSTR WINAPI PathSkipRootA(LPCSTR pszPath)
    17461747{
    1747         FIXME("%s\n", pszPath);
    1748         return (LPSTR)pszPath;
    1749 }
    1750 
    1751 /*************************************************************************
    1752  *      PathSkipRootW   [SHLWAPI.@]
     1748    FIXME("%s\n", pszPath);
     1749    return (LPSTR)pszPath;
     1750}
     1751
     1752/*************************************************************************
     1753 *  PathSkipRootW   [SHLWAPI.@]
    17531754 */
    17541755LPWSTR WINAPI PathSkipRootW(LPCWSTR pszPath)
    17551756{
    1756         FIXME("%s\n", debugstr_w(pszPath));
    1757         return (LPWSTR)pszPath;
     1757    FIXME("%s\n", debugstr_w(pszPath));
     1758    return (LPWSTR)pszPath;
    17581759}
    17591760#endif
    17601761
    17611762/*************************************************************************
    1762  *      PathCreateFromUrlA   [SHLWAPI.@]
     1763 *  PathCreateFromUrlA   [SHLWAPI.@]
    17631764 */
    17641765HRESULT WINAPI PathCreateFromUrlA(
    1765         LPCSTR pszUrl,
    1766         LPSTR pszPath,
    1767         LPDWORD pcchPath,
    1768         DWORD dwFlags)
    1769 {
    1770         FIXME("%s %p %p 0x%08lx\n",
    1771           pszUrl, pszPath, pcchPath, dwFlags);
    1772         return S_OK;
    1773 }
    1774 
    1775 /*************************************************************************
    1776  *      PathCreateFromUrlW   [SHLWAPI.@]
     1766    LPCSTR pszUrl,
     1767    LPSTR pszPath,
     1768    LPDWORD pcchPath,
     1769    DWORD dwFlags)
     1770{
     1771    FIXME("%s %p %p 0x%08lx\n",
     1772      pszUrl, pszPath, pcchPath, dwFlags);
     1773    return S_OK;
     1774}
     1775
     1776/*************************************************************************
     1777 *  PathCreateFromUrlW   [SHLWAPI.@]
    17771778 */
    17781779HRESULT WINAPI PathCreateFromUrlW(
    1779         LPCWSTR pszUrl,
    1780         LPWSTR pszPath,
    1781         LPDWORD pcchPath,
    1782         DWORD dwFlags)
    1783 {
    1784         FIXME("%s %p %p 0x%08lx\n",
    1785           debugstr_w(pszUrl), pszPath, pcchPath, dwFlags);
    1786         return S_OK;
    1787 }
    1788 
    1789 /*************************************************************************
    1790  *      PathRelativePathToA   [SHLWAPI.@]
     1780    LPCWSTR pszUrl,
     1781    LPWSTR pszPath,
     1782    LPDWORD pcchPath,
     1783    DWORD dwFlags)
     1784{
     1785    FIXME("%s %p %p 0x%08lx\n",
     1786      debugstr_w(pszUrl), pszPath, pcchPath, dwFlags);
     1787    return S_OK;
     1788}
     1789
     1790/*************************************************************************
     1791 *  PathRelativePathToA   [SHLWAPI.@]
    17911792 */
    17921793BOOL WINAPI PathRelativePathToA(
    1793         LPSTR pszPath,
    1794         LPCSTR pszFrom,
    1795         DWORD dwAttrFrom,
    1796         LPCSTR pszTo,
    1797         DWORD dwAttrTo)
    1798 {
    1799         FIXME("%s %s 0x%08lx %s 0x%08lx\n",
    1800           pszPath, pszFrom, dwAttrFrom, pszTo, dwAttrTo);
    1801         return FALSE;
    1802 }
    1803 
    1804 /*************************************************************************
    1805  *      PathRelativePathToW   [SHLWAPI.@]
     1794    LPSTR pszPath,
     1795    LPCSTR pszFrom,
     1796    DWORD dwAttrFrom,
     1797    LPCSTR pszTo,
     1798    DWORD dwAttrTo)
     1799{
     1800    FIXME("%s %s 0x%08lx %s 0x%08lx\n",
     1801      pszPath, pszFrom, dwAttrFrom, pszTo, dwAttrTo);
     1802    return FALSE;
     1803}
     1804
     1805/*************************************************************************
     1806 *  PathRelativePathToW   [SHLWAPI.@]
    18061807 */
    18071808BOOL WINAPI PathRelativePathToW(
    1808         LPWSTR pszPath,
    1809         LPCWSTR pszFrom,
    1810         DWORD dwAttrFrom,
    1811         LPCWSTR pszTo,
    1812         DWORD dwAttrTo)
    1813 {
    1814         FIXME("%s %s 0x%08lx %s 0x%08lx\n",
    1815           debugstr_w(pszPath), debugstr_w(pszFrom), dwAttrFrom, debugstr_w(pszTo), dwAttrTo);
    1816         return FALSE;
    1817 }
    1818 
    1819 /*************************************************************************
    1820  *      PathUnmakeSystemFolderA   [SHLWAPI.@]
     1809    LPWSTR pszPath,
     1810    LPCWSTR pszFrom,
     1811    DWORD dwAttrFrom,
     1812    LPCWSTR pszTo,
     1813    DWORD dwAttrTo)
     1814{
     1815    FIXME("%s %s 0x%08lx %s 0x%08lx\n",
     1816      debugstr_w(pszPath), debugstr_w(pszFrom), dwAttrFrom, debugstr_w(pszTo), dwAttrTo);
     1817    return FALSE;
     1818}
     1819
     1820/*************************************************************************
     1821 *  PathUnmakeSystemFolderA   [SHLWAPI.@]
    18211822 */
    18221823BOOL WINAPI PathUnmakeSystemFolderA(LPCSTR pszPath)
    18231824{
    1824         FIXME("%s\n", pszPath);
    1825         return FALSE;
    1826 }
    1827 
    1828 /*************************************************************************
    1829  *      PathUnmakeSystemFolderW   [SHLWAPI.@]
     1825    FIXME("%s\n", pszPath);
     1826    return FALSE;
     1827}
     1828
     1829/*************************************************************************
     1830 *  PathUnmakeSystemFolderW   [SHLWAPI.@]
    18301831 */
    18311832BOOL WINAPI PathUnmakeSystemFolderW(LPCWSTR pszPath)
    18321833{
    1833         FIXME("%s\n", debugstr_w(pszPath));
    1834         return FALSE;
     1834    FIXME("%s\n", debugstr_w(pszPath));
     1835    return FALSE;
    18351836}
    18361837
    18371838/*
    1838         ########## special ##########
     1839    ########## special ##########
    18391840*/
    18401841
    … …  
    18451846 *  use PathCompactPath to make sure, the path fits into the control
    18461847 */
    1847 BOOL WINAPI PathSetDlgItemPathA(HWND hDlg, int id, LPCSTR pszPath) 
    1848 {       TRACE("%x %x %s\n",hDlg, id, pszPath);
    1849         return SetDlgItemTextA(hDlg, id, pszPath);
     1848BOOL WINAPI PathSetDlgItemPathA(HWND hDlg, int id, LPCSTR pszPath)
     1849{   TRACE("%x %x %s\n",hDlg, id, pszPath);
     1850    return SetDlgItemTextA(hDlg, id, pszPath);
    18501851}
    18511852
    … …  
    18531854 * PathSetDlgItemPathW   [SHLWAPI.@]
    18541855 */
    1855 BOOL WINAPI PathSetDlgItemPathW(HWND hDlg, int id, LPCWSTR pszPath) 
    1856 {       TRACE("%x %x %s\n",hDlg, id, debugstr_w(pszPath));
    1857         return SetDlgItemTextW(hDlg, id, pszPath);
    1858 }
     1856BOOL WINAPI PathSetDlgItemPathW(HWND hDlg, int id, LPCWSTR pszPath)
     1857{   TRACE("%x %x %s\n",hDlg, id, debugstr_w(pszPath));
     1858    return SetDlgItemTextW(hDlg, id, pszPath);
     1859}
Note: See TracChangeset for help on using the changeset viewer.