Ignore:
Timestamp:
Sep 15, 2001, 11:47:44 AM (24 years ago)
Author:
sandervl
Message:

restored old version

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shlwapi/path.c

    r6650 r6712  
    1 /* $Id: path.c,v 1.14 2001-09-05 13:48:38 bird Exp $ */
    21/*
    32 * Path Functions
    … …  
    4342#define isSlash(x) ((x)=='\\' || (x)=='/')
    4443/*
    45     ########## Combining and Constructing paths ##########
     44        ########## Combining and Constructing paths ##########
    4645*/
    4746
    4847/*************************************************************************
    49  * PathAppendA      [SHLWAPI.@]
    50  *
     48 * PathAppendA          [SHLWAPI.@]
     49 * 
    5150 * NOTES
    5251 *  concat path lpszPath2 onto lpszPath1
    … …  
    5655 */
    5756BOOL WINAPI PathAppendA(
    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.@]
     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.@]
    6968 */
    7069BOOL WINAPI PathAppendW(
    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  *
     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 * 
    8382 * NOTES
    8483 *  if lpszFile='.' skip it
    … …  
    8988 */
    9089LPSTR WINAPI PathCombineA(
    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.@]
     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.@]
    129128 */
    130129LPWSTR WINAPI PathCombineW(
    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     {
     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        {
    142141          strcpyW(szDest,lpszDir);
    143       return szDest;
    144     }
    145 
    146     /*  if lpszFile is a complete path don't care about lpszDir */
    147     if (PathGetDriveNumberW(lpszFile) != -1)
    148     {
     142          return szDest;
     143        }
     144
     145        /*  if lpszFile is a complete path don't care about lpszDir */
     146        if (PathGetDriveNumberW(lpszFile) != -1)
     147        {
    149148            strcpyW(szDest,lpszFile);
    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.@]
     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.@]
    170169 *
    171170 * NOTES
    … …  
    174173LPSTR WINAPI PathAddBackslashA(LPSTR lpszPath)
    175174{
    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.@]
     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.@]
    191190 */
    192191LPWSTR WINAPI PathAddBackslashW(LPWSTR lpszPath)
    193192{
    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  */
    210 LPSTR 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  */
    222 LPWSTR 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;
     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 */
     209LPSTR 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 */
     221LPWSTR 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;
    230229}
    231230
    232231/*
    233     Extracting Component Parts
     232        Extracting Component Parts
    234233*/
    235234
    236235/*************************************************************************
    237  * PathFindFileNameA    [SHLWAPI.@]
     236 * PathFindFileNameA    [SHLWAPI.@]
    238237 */
    239238LPSTR WINAPI PathFindFileNameA(LPCSTR lpszPath)
    240239{
    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.@]
     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.@]
    256255 */
    257256LPWSTR WINAPI PathFindFileNameW(LPCWSTR lpszPath)
    258257{
    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.@]
     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.@]
    274273 *
    275274 * NOTES
    … …  
    277276 */
    278277
    279 LPSTR 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  */
    299 LPWSTR 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.@]
     278LPSTR 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 */
     298LPWSTR 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.@]
    318317 *
    319318 * NOTES
    … …  
    324323 *     quoting by '\'
    325324 */
    326 LPSTR 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  */
    346 LPWSTR 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.@]
     325LPSTR 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 */
     345LPWSTR 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.@]
    365364 */
    366365int WINAPI PathGetDriveNumberA(LPCSTR lpszPath)
    367366{
    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.@]
     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.@]
    378377 */
    379378int WINAPI PathGetDriveNumberW(LPCWSTR lpszPath)
    380379{
    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  *
     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 * 
    392391 * NOTES
    393392 *     truncates passed argument to a valid path
    … …  
    395394 *     "\foo\xx\foo"-> "\foo\xx"
    396395 *     "\" -> "\"
    397  *     "a:\foo" -> "a:\"
     396 *     "a:\foo" -> "a:\"
    398397 */
    399398BOOL WINAPI PathRemoveFileSpecA(LPSTR lpszPath)
    400399{
    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.@]
     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.@]
    432431 */
    433432BOOL WINAPI PathRemoveFileSpecW(LPWSTR lpszPath)
    434433{
    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  *
     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 * 
    467466 * NOTES
    468467 *  removes the path from the beginning of a filename
    … …  
    470469void WINAPI PathStripPathA(LPSTR lpszPath)
    471470{
    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.@]
     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.@]
    482481 */
    483482void WINAPI PathStripPathW(LPWSTR lpszPath)
    484483{
    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.@]
     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.@]
    494493 */
    495494BOOL WINAPI PathStripToRootA(LPSTR lpszPath)
    496495{
    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.@]
     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.@]
    507506 */
    508507BOOL WINAPI PathStripToRootW(LPWSTR lpszPath)
    509508{
    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.@]
     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.@]
    520519 *
    521520 */
    522521void WINAPI PathRemoveArgsA(LPSTR lpszPath)
    523522{
    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.@]
     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.@]
    539538 */
    540539void WINAPI PathRemoveArgsW(LPWSTR lpszPath)
    541540{
    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.@]
     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.@]
    557556 */
    558557void WINAPI PathRemoveExtensionA(LPSTR lpszPath)
    559558{
    560     LPSTR lpszExtension = PathFindExtensionA(lpszPath);
    561 
    562     TRACE("%s\n", lpszPath);
    563 
    564     if (lpszExtension) *lpszExtension='\0';
    565 }
    566 
    567 /*************************************************************************
    568  * PathRemoveExtensionW     [SHLWAPI.@]
     559        LPSTR lpszExtension = PathFindExtensionA(lpszPath);
     560
     561        TRACE("%s\n", lpszPath);
     562
     563        if (lpszExtension) *lpszExtension='\0';
     564}
     565
     566/*************************************************************************
     567 * PathRemoveExtensionW         [SHLWAPI.@]
    569568 */
    570569void WINAPI PathRemoveExtensionW(LPWSTR lpszPath)
    571570{
    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.@]
     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.@]
    581580 *
    582581 * If the path ends in a backslash it is replaced by a NULL
    583582 * and the address of the NULL is returned
    584  * Otherwise
     583 * Otherwise 
    585584 * the address of the last character is returned.
    586585 *
    … …  
    590589LPSTR WINAPI PathRemoveBackslashA( LPSTR lpszPath )
    591590{
    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.@]
     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.@]
    609608 */
    610609LPWSTR WINAPI PathRemoveBackslashW( LPWSTR lpszPath )
    611610{
    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;
     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;
    625624}
    626625
    627626
    628627/*
    629     Path Manipulations
     628        Path Manipulations
    630629*/
    631630
    632631/*************************************************************************
    633632 * PathRemoveBlanksA [SHLWAPI.@]
    634  *
     633 * 
    635634 * NOTES
    636635 *     remove spaces from beginning and end of passed string
    … …  
    638637void WINAPI PathRemoveBlanksA(LPSTR str)
    639638{
    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     }
     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        }
    652651}
    653652
    … …  
    657656void WINAPI PathRemoveBlanksW(LPWSTR str)
    658657{
    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     }
     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        }
    671670}
    672671
    673672/*************************************************************************
    674673 * PathQuoteSpacesA [SHLWAPI.@]
    675  *
     674 * 
    676675 */
    677676LPSTR WINAPI PathQuoteSpacesA(LPSTR lpszPath)
    678677{
    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;
     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;
    692691}
    693692
    … …  
    697696LPWSTR WINAPI PathQuoteSpacesW(LPWSTR lpszPath)
    698697{
    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;
     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;
    712711}
    713712
    714713/*************************************************************************
    715714 * PathUnquoteSpacesA [SHLWAPI.@]
    716  *
     715 * 
    717716 * NOTES
    718717 *     unquote string (remove ")
    719718 */
    720 VOID 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;
     719VOID 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;
    733732}
    734733
    … …  
    736735 * PathUnquoteSpacesW [SHLWAPI.@]
    737736 */
    738 VOID 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.@]
     737VOID 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.@]
    755754 */
    756755int WINAPI PathParseIconLocationA(LPSTR lpszPath)
    757756{
    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.@]
     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.@]
    774773 */
    775774int WINAPI PathParseIconLocationW(LPWSTR lpszPath)
    776775{
    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;
     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;
    788787}
    789788
    790789/*
    791     ########## cleaning and resolving paths ##########
    792  */
    793 
    794 /*************************************************************************
    795  * PathFindOnPathA  [SHLWAPI.@]
     790        ########## cleaning and resolving paths ##########
     791 */
     792
     793/*************************************************************************
     794 * PathFindOnPathA      [SHLWAPI.@]
    796795 */
    797796BOOL WINAPI PathFindOnPathA(LPSTR sFile, LPCSTR sOtherDirs)
    798797{
    799     FIXME("%s %s\n",sFile, sOtherDirs);
    800     return FALSE;
    801 }
    802 
    803 /*************************************************************************
    804  * PathFindOnPathW  [SHLWAPI.@]
     798        FIXME("%s %s\n",sFile, sOtherDirs);
     799        return FALSE;
     800}
     801
     802/*************************************************************************
     803 * PathFindOnPathW      [SHLWAPI.@]
    805804 */
    806805BOOL WINAPI PathFindOnPathW(LPWSTR sFile, LPCWSTR sOtherDirs)
    807806{
    808     FIXME("%s %s\n",debugstr_w(sFile), debugstr_w(sOtherDirs));
    809     return FALSE;
    810 }
    811 
    812 /*************************************************************************
    813  *  PathCompactPathExA   [SHLWAPI.@]
     807        FIXME("%s %s\n",debugstr_w(sFile), debugstr_w(sOtherDirs));
     808        return FALSE;
     809}
     810
     811/*************************************************************************
     812 *      PathCompactPathExA   [SHLWAPI.@]
    814813 */
    815814BOOL WINAPI PathCompactPathExA(
    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.@]
     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.@]
    827826 */
    828827BOOL WINAPI PathCompactPathExW(
    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;
     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;
    836835}
    837836
    838837/*
    839     ########## Path Testing ##########
     838        ########## Path Testing ##########
    840839*/
    841840
    842841/*************************************************************************
    843  * PathIsUNCA       [SHLWAPI.@]
    844  *
     842 * PathIsUNCA           [SHLWAPI.@]
     843 * 
    845844 * NOTES
    846845 *     PathIsUNC(char*path);
    847846 */
    848 BOOL 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  */
    858 BOOL 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.@]
     847BOOL 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 */
     857BOOL 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.@]
    867866 */
    868867BOOL WINAPI PathIsRelativeA (LPCSTR lpszPath)
    869868{
    870     TRACE("lpszPath=%s\n",lpszPath);
    871 
    872     return (lpszPath && (lpszPath[0]!='\\' && lpszPath[1]!=':'));
    873 }
    874 
    875 /*************************************************************************
    876  *  PathIsRelativeW [SHLWAPI.@]
     869        TRACE("lpszPath=%s\n",lpszPath);
     870
     871        return (lpszPath && (lpszPath[0]!='\\' && lpszPath[1]!=':'));
     872}
     873
     874/*************************************************************************
     875 *  PathIsRelativeW     [SHLWAPI.@]
    877876 */
    878877BOOL WINAPI PathIsRelativeW (LPCWSTR lpszPath)
    879878{
    880     TRACE("lpszPath=%s\n",debugstr_w(lpszPath));
    881 
    882     return (lpszPath && (lpszPath[0]!='\\' && lpszPath[1]!=':'));
    883 }
    884 
    885 /*************************************************************************
    886  * PathIsRootA      [SHLWAPI.@]
     879        TRACE("lpszPath=%s\n",debugstr_w(lpszPath));
     880
     881        return (lpszPath && (lpszPath[0]!='\\' && lpszPath[1]!=':'));
     882}
     883
     884/*************************************************************************
     885 * PathIsRootA          [SHLWAPI.@]
    887886 *
    888887 * notes
    … …  
    891890BOOL WINAPI PathIsRootA(LPCSTR lpszPath)
    892891{
    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  */
    922 BOOL 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.@]
     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 */
     921BOOL 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.@]
    953952 */
    954953BOOL WINAPI PathIsDirectoryA(LPCSTR lpszPath)
    955954{
    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.@]
     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.@]
    966965 */
    967966BOOL WINAPI PathIsDirectoryW(LPCWSTR lpszPath)
    968967{
    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  *
     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 * 
    980979 * NOTES
    981980 *     file_exists(char *fn);
    982981 */
    983 BOOL WINAPI PathFileExistsA(LPCSTR lpszPath)
    984 {
    985     TRACE("%s\n",lpszPath);
    986     return  (GetFileAttributesA(lpszPath)!=-1);
    987 }
    988 
    989 /*************************************************************************
    990  * PathFileExistsW  [SHLWAPI.@]
    991  */
    992 BOOL WINAPI PathFileExistsW(LPCWSTR lpszPath)
    993 {
    994     TRACE("%s\n",debugstr_w(lpszPath));
    995     return  (GetFileAttributesW(lpszPath)!=-1);
    996 }
    997 
    998 /*************************************************************************
    999  * PathMatchSingleMaskA [internal]
    1000  *
     982BOOL WINAPI PathFileExistsA(LPCSTR lpszPath) 
     983{
     984        TRACE("%s\n",lpszPath);
     985        return  (GetFileAttributesA(lpszPath)!=-1);
     986}
     987
     988/*************************************************************************
     989 * PathFileExistsW      [SHLWAPI.@]
     990 */
     991BOOL WINAPI PathFileExistsW(LPCWSTR lpszPath) 
     992{
     993        TRACE("%s\n",debugstr_w(lpszPath));
     994        return  (GetFileAttributesW(lpszPath)!=-1);
     995}
     996
     997/*************************************************************************
     998 * PathMatchSingleMaskA [internal]
     999 * 
    10011000 * NOTES
    10021001 *     internal (used by PathMatchSpec)
    … …  
    10041003static BOOL PathMatchSingleMaskA(LPCSTR name, LPCSTR mask)
    10051004{
    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]
     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]
    10301029 */
    10311030static BOOL PathMatchSingleMaskW(LPCWSTR name, LPCWSTR mask)
    10321031{
    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  *
     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 * 
    10571056 * NOTES
    10581057 *     used from COMDLG32
    10591058 */
    1060 BOOL 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  */
    1082 BOOL WINAPI PathMatchSpecW(LPCWSTR name, LPCWSTR mask)
     1059BOOL 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 */
     1081BOOL WINAPI PathMatchSpecW(LPCWSTR name, LPCWSTR mask) 
    10831082{
    10841083    static const WCHAR stemp[] = { '*','.','*',0 };
    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.@]
     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.@]
    11041103 *
    11051104 * FIXME
    … …  
    11081107BOOL WINAPI PathIsSameRootA(LPCSTR lpszPath1, LPCSTR lpszPath2)
    11091108{
    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.@]
     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.@]
    11391138 */
    11401139BOOL WINAPI PathIsSameRootW(LPCWSTR lpszPath1, LPCWSTR lpszPath2)
    11411140{
    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;
     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;
    11671166}
    11681167
    … …  
    11801179  // DWORD dwUnknown = SHREG_xxx; // 0x18
    11811180  // return SHLWAPI_1(lpstrPath, &dwUnknown);
    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 }
     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} 
    12061205
    12071206/*************************************************************************
    … …  
    12101209BOOL WINAPI PathIsURLW(LPCWSTR lpstrPath)
    12111210{
    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.@]
     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.@]
    12401239 */
    12411240BOOL WINAPI PathIsContentTypeA(LPCSTR pszPath, LPCSTR pszContentType)
    12421241{
    1243     FIXME("%s %s\n", pszPath, pszContentType);
    1244     return FALSE;
    1245 }
    1246 
    1247 /*************************************************************************
    1248  *  PathIsContentTypeW   [SHLWAPI.@]
     1242        FIXME("%s %s\n", pszPath, pszContentType);
     1243        return FALSE;
     1244}
     1245
     1246/*************************************************************************
     1247 *      PathIsContentTypeW   [SHLWAPI.@]
    12491248 */
    12501249BOOL WINAPI PathIsContentTypeW(LPCWSTR pszPath, LPCWSTR pszContentType)
    12511250{
    1252     FIXME("%s %s\n", debugstr_w(pszPath), debugstr_w(pszContentType));
    1253     return FALSE;
    1254 }
    1255 
    1256 /*************************************************************************
    1257  *  PathIsFileSpecA   [SHLWAPI.@]
     1251        FIXME("%s %s\n", debugstr_w(pszPath), debugstr_w(pszContentType));
     1252        return FALSE;
     1253}
     1254
     1255/*************************************************************************
     1256 *      PathIsFileSpecA   [SHLWAPI.@]
    12581257 */
    12591258BOOL WINAPI PathIsFileSpecA(LPCSTR pszPath)
    12601259{
    1261     FIXME("%s\n", pszPath);
    1262     return FALSE;
    1263 }
    1264 
    1265 /*************************************************************************
    1266  *  PathIsFileSpecW   [SHLWAPI.@]
     1260        FIXME("%s\n", pszPath);
     1261        return FALSE;
     1262}
     1263
     1264/*************************************************************************
     1265 *      PathIsFileSpecW   [SHLWAPI.@]
    12671266 */
    12681267BOOL WINAPI PathIsFileSpecW(LPCWSTR pszPath)
    12691268{
    1270     FIXME("%s\n", debugstr_w(pszPath));
    1271     return FALSE;
    1272 }
    1273 
    1274 /*************************************************************************
    1275  *  PathIsPrefixA   [SHLWAPI.@]
     1269        FIXME("%s\n", debugstr_w(pszPath));
     1270        return FALSE;
     1271}
     1272
     1273/*************************************************************************
     1274 *      PathIsPrefixA   [SHLWAPI.@]
    12761275 */
    12771276BOOL WINAPI PathIsPrefixA(LPCSTR pszPrefix, LPCSTR pszPath)
    12781277{
    1279     FIXME("%s %s\n", pszPrefix, pszPath);
    1280     return FALSE;
    1281 }
    1282 
    1283 /*************************************************************************
    1284  *  PathIsPrefixW   [SHLWAPI.@]
     1278        FIXME("%s %s\n", pszPrefix, pszPath);
     1279        return FALSE;
     1280}
     1281
     1282/*************************************************************************
     1283 *      PathIsPrefixW   [SHLWAPI.@]
    12851284 */
    12861285BOOL WINAPI PathIsPrefixW(LPCWSTR pszPrefix, LPCWSTR pszPath)
    12871286{
    1288     FIXME("%s %s\n", debugstr_w(pszPrefix), debugstr_w(pszPath));
    1289     return FALSE;
    1290 }
    1291 
    1292 /*************************************************************************
    1293  *  PathIsSystemFolderA   [SHLWAPI.@]
     1287        FIXME("%s %s\n", debugstr_w(pszPrefix), debugstr_w(pszPath));
     1288        return FALSE;
     1289}
     1290
     1291/*************************************************************************
     1292 *      PathIsSystemFolderA   [SHLWAPI.@]
    12941293 */
    12951294BOOL WINAPI PathIsSystemFolderA(LPCSTR pszPath, DWORD dwAttrb)
    12961295{
    1297     FIXME("%s 0x%08lx\n", pszPath, dwAttrb);
    1298     return FALSE;
    1299 }
    1300 
    1301 /*************************************************************************
    1302  *  PathIsSystemFolderW   [SHLWAPI.@]
     1296        FIXME("%s 0x%08lx\n", pszPath, dwAttrb);
     1297        return FALSE;
     1298}
     1299
     1300/*************************************************************************
     1301 *      PathIsSystemFolderW   [SHLWAPI.@]
    13031302 */
    13041303BOOL WINAPI PathIsSystemFolderW(LPCWSTR pszPath, DWORD dwAttrb)
    13051304{
    1306     FIXME("%s 0x%08lx\n", debugstr_w(pszPath), dwAttrb);
    1307     return FALSE;
    1308 }
    1309 
    1310 /*************************************************************************
    1311  *  PathIsUNCServerA   [SHLWAPI.@]
     1305        FIXME("%s 0x%08lx\n", debugstr_w(pszPath), dwAttrb);
     1306        return FALSE;
     1307}
     1308
     1309/*************************************************************************
     1310 *      PathIsUNCServerA   [SHLWAPI.@]
    13121311 */
    13131312BOOL WINAPI PathIsUNCServerA(
    1314     LPCSTR pszPath)
    1315 {
    1316     FIXME("%s\n", pszPath);
    1317     return FALSE;
    1318 }
    1319 
    1320 /*************************************************************************
    1321  *  PathIsUNCServerW   [SHLWAPI.@]
     1313        LPCSTR pszPath)
     1314{
     1315        FIXME("%s\n", pszPath);
     1316        return FALSE;
     1317}
     1318
     1319/*************************************************************************
     1320 *      PathIsUNCServerW   [SHLWAPI.@]
    13221321 */
    13231322BOOL WINAPI PathIsUNCServerW(
    1324     LPCWSTR pszPath)
    1325 {
    1326     FIXME("%s\n", debugstr_w(pszPath));
    1327     return FALSE;
    1328 }
    1329 
    1330 /*************************************************************************
    1331  *  PathIsUNCServerShareA   [SHLWAPI.@]
     1323        LPCWSTR pszPath)
     1324{
     1325        FIXME("%s\n", debugstr_w(pszPath));
     1326        return FALSE;
     1327}
     1328
     1329/*************************************************************************
     1330 *      PathIsUNCServerShareA   [SHLWAPI.@]
    13321331 */
    13331332BOOL WINAPI PathIsUNCServerShareA(
    1334     LPCSTR pszPath)
    1335 {
    1336     FIXME("%s\n", pszPath);
    1337     return FALSE;
    1338 }
    1339 
    1340 /*************************************************************************
    1341  *  PathIsUNCServerShareW   [SHLWAPI.@]
     1333        LPCSTR pszPath)
     1334{
     1335        FIXME("%s\n", pszPath);
     1336        return FALSE;
     1337}
     1338
     1339/*************************************************************************
     1340 *      PathIsUNCServerShareW   [SHLWAPI.@]
    13421341 */
    13431342BOOL WINAPI PathIsUNCServerShareW(
    1344     LPCWSTR pszPath)
    1345 {
    1346     FIXME("%s\n", debugstr_w(pszPath));
    1347     return FALSE;
     1343        LPCWSTR pszPath)
     1344{
     1345        FIXME("%s\n", debugstr_w(pszPath));
     1346        return FALSE;
    13481347}
    13491348
    … …  
    13541353 *   returnvalue, use CharNext
    13551354 */
    1356 
     1355 
    13571356BOOL WINAPI PathCanonicalizeA(LPSTR pszBuf, LPCSTR pszPath)
    13581357{
    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         }
     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            }
    13881387          }
    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;
     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;
    14201419}
    14211420
    … …  
    14291428BOOL WINAPI PathCanonicalizeW(LPWSTR pszBuf, LPCWSTR pszPath)
    14301429{
    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         }
     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            }
    14601459          }
    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;
     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;
    14921491}
    14931492
    … …  
    14971496 * NOTES
    14981497 * special cases:
    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
     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
    15081507*/
    15091508LPSTR WINAPI PathFindNextComponentA(LPCSTR pszPath)
    15101509{
    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;
     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;
    15211520}
    15221521
    … …  
    15261525LPWSTR WINAPI PathFindNextComponentW(LPCWSTR pszPath)
    15271526{
    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;
     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;
    15381537}
    15391538
    … …  
    15441543 *  it adds never a dot
    15451544 */
    1546 
     1545 
    15471546BOOL WINAPI PathAddExtensionA(
    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.@]
     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.@]
    15661565 */
    15671566BOOL WINAPI PathAddExtensionW(
    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.@]
     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.@]
    15881587 */
    15891588BOOL WINAPI PathMakePrettyA(
    1590     LPSTR lpPath)
    1591 {
    1592     FIXME("%s\n", lpPath);
    1593     return TRUE;
    1594 }
    1595 
    1596 /*************************************************************************
    1597  *  PathMakePrettyW   [SHLWAPI.@]
     1589        LPSTR lpPath)
     1590{
     1591        FIXME("%s\n", lpPath);
     1592        return TRUE;
     1593}
     1594
     1595/*************************************************************************
     1596 *      PathMakePrettyW   [SHLWAPI.@]
    15981597 */
    15991598BOOL WINAPI PathMakePrettyW(
    1600     LPWSTR lpPath)
    1601 {
    1602     FIXME("%s\n", debugstr_w(lpPath));
    1603     return TRUE;
    1604 
    1605 }
    1606 
    1607 /*************************************************************************
    1608  *  PathCommonPrefixA   [SHLWAPI.@]
     1599        LPWSTR lpPath)
     1600{
     1601        FIXME("%s\n", debugstr_w(lpPath));
     1602        return TRUE;
     1603
     1604}
     1605
     1606/*************************************************************************
     1607 *      PathCommonPrefixA   [SHLWAPI.@]
    16091608 */
    16101609int WINAPI PathCommonPrefixA(
    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.@]
     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.@]
    16211620 */
    16221621int WINAPI PathCommonPrefixW(
    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.@]
     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.@]
    16331632 */
    16341633BOOL WINAPI PathCompactPathA(HDC hDC, LPSTR pszPath, UINT dx)
    16351634{
    1636     FIXME("0x%08x %s 0x%08x\n", hDC, pszPath, dx);
    1637     return FALSE;
    1638 }
    1639 
    1640 /*************************************************************************
    1641  *  PathCompactPathW   [SHLWAPI.@]
     1635        FIXME("0x%08x %s 0x%08x\n", hDC, pszPath, dx);
     1636        return FALSE;
     1637}
     1638
     1639/*************************************************************************
     1640 *      PathCompactPathW   [SHLWAPI.@]
    16421641 */
    16431642BOOL WINAPI PathCompactPathW(HDC hDC, LPWSTR pszPath, UINT dx)
    16441643{
    1645     FIXME("0x%08x %s 0x%08x\n", hDC, debugstr_w(pszPath), dx);
    1646     return FALSE;
    1647 }
    1648 
    1649 /*************************************************************************
    1650  *  PathGetCharTypeA   [SHLWAPI.@]
     1644        FIXME("0x%08x %s 0x%08x\n", hDC, debugstr_w(pszPath), dx);
     1645        return FALSE;
     1646}
     1647
     1648/*************************************************************************
     1649 *      PathGetCharTypeA   [SHLWAPI.@]
    16511650 */
    16521651UINT WINAPI PathGetCharTypeA(UCHAR ch)
    … …  
    16541653        UINT flags = 0;
    16551654
    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.@]
     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.@]
    16751674 */
    16761675UINT WINAPI PathGetCharTypeW(WCHAR ch)
    16771676{
    1678     FIXME("%c, using ascii version\n", ch);
    1679     return PathGetCharTypeA(ch);
    1680 }
    1681 
    1682 /*************************************************************************
    1683  *  PathMakeSystemFolderA   [SHLWAPI.@]
     1677        FIXME("%c, using ascii version\n", ch);
     1678        return PathGetCharTypeA(ch);
     1679}
     1680
     1681/*************************************************************************
     1682 *      PathMakeSystemFolderA   [SHLWAPI.@]
    16841683 */
    16851684BOOL WINAPI PathMakeSystemFolderA(LPCSTR pszPath)
    16861685{
    1687     FIXME("%s\n", pszPath);
    1688     return FALSE;
    1689 }
    1690 
    1691 /*************************************************************************
    1692  *  PathMakeSystemFolderW   [SHLWAPI.@]
     1686        FIXME("%s\n", pszPath);
     1687        return FALSE;
     1688}
     1689
     1690/*************************************************************************
     1691 *      PathMakeSystemFolderW   [SHLWAPI.@]
    16931692 */
    16941693BOOL WINAPI PathMakeSystemFolderW(LPCWSTR pszPath)
    16951694{
    1696     FIXME("%s\n", debugstr_w(pszPath));
    1697     return FALSE;
    1698 }
    1699 
    1700 /*************************************************************************
    1701  *  PathRenameExtensionA   [SHLWAPI.@]
     1695        FIXME("%s\n", debugstr_w(pszPath));
     1696        return FALSE;
     1697}
     1698
     1699/*************************************************************************
     1700 *      PathRenameExtensionA   [SHLWAPI.@]
    17021701 */
    17031702BOOL WINAPI PathRenameExtensionA(LPSTR pszPath, LPCSTR pszExt)
    17041703{
    1705     FIXME("%s %s\n", pszPath, pszExt);
    1706     return FALSE;
    1707 }
    1708 
    1709 /*************************************************************************
    1710  *  PathRenameExtensionW   [SHLWAPI.@]
     1704        FIXME("%s %s\n", pszPath, pszExt);
     1705        return FALSE;
     1706}
     1707
     1708/*************************************************************************
     1709 *      PathRenameExtensionW   [SHLWAPI.@]
    17111710 */
    17121711BOOL WINAPI PathRenameExtensionW(LPWSTR pszPath, LPCWSTR pszExt)
    17131712{
    1714     FIXME("%s %s\n", debugstr_w(pszPath), debugstr_w(pszExt));
    1715     return FALSE;
    1716 }
    1717 
    1718 /*************************************************************************
    1719  *  PathSearchAndQualifyA   [SHLWAPI.@]
     1713        FIXME("%s %s\n", debugstr_w(pszPath), debugstr_w(pszExt));
     1714        return FALSE;
     1715}
     1716
     1717/*************************************************************************
     1718 *      PathSearchAndQualifyA   [SHLWAPI.@]
    17201719 */
    17211720BOOL WINAPI PathSearchAndQualifyA(
    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.@]
     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.@]
    17321731 */
    17331732BOOL WINAPI PathSearchAndQualifyW(
    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;
     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;
    17401739}
    17411740
    17421741#ifndef __WIN32OS2__
    17431742/*************************************************************************
    1744  *  PathSkipRootA   [SHLWAPI.@]
     1743 *      PathSkipRootA   [SHLWAPI.@]
    17451744 */
    17461745LPSTR WINAPI PathSkipRootA(LPCSTR pszPath)
    17471746{
    1748     FIXME("%s\n", pszPath);
    1749     return (LPSTR)pszPath;
    1750 }
    1751 
    1752 /*************************************************************************
    1753  *  PathSkipRootW   [SHLWAPI.@]
     1747        FIXME("%s\n", pszPath);
     1748        return (LPSTR)pszPath;
     1749}
     1750
     1751/*************************************************************************
     1752 *      PathSkipRootW   [SHLWAPI.@]
    17541753 */
    17551754LPWSTR WINAPI PathSkipRootW(LPCWSTR pszPath)
    17561755{
    1757     FIXME("%s\n", debugstr_w(pszPath));
    1758     return (LPWSTR)pszPath;
     1756        FIXME("%s\n", debugstr_w(pszPath));
     1757        return (LPWSTR)pszPath;
    17591758}
    17601759#endif
    17611760
    17621761/*************************************************************************
    1763  *  PathCreateFromUrlA   [SHLWAPI.@]
     1762 *      PathCreateFromUrlA   [SHLWAPI.@]
    17641763 */
    17651764HRESULT WINAPI PathCreateFromUrlA(
    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.@]
     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.@]
    17781777 */
    17791778HRESULT WINAPI PathCreateFromUrlW(
    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.@]
     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.@]
    17921791 */
    17931792BOOL WINAPI PathRelativePathToA(
    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.@]
     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.@]
    18071806 */
    18081807BOOL WINAPI PathRelativePathToW(
    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.@]
     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.@]
    18221821 */
    18231822BOOL WINAPI PathUnmakeSystemFolderA(LPCSTR pszPath)
    18241823{
    1825     FIXME("%s\n", pszPath);
    1826     return FALSE;
    1827 }
    1828 
    1829 /*************************************************************************
    1830  *  PathUnmakeSystemFolderW   [SHLWAPI.@]
     1824        FIXME("%s\n", pszPath);
     1825        return FALSE;
     1826}
     1827
     1828/*************************************************************************
     1829 *      PathUnmakeSystemFolderW   [SHLWAPI.@]
    18311830 */
    18321831BOOL WINAPI PathUnmakeSystemFolderW(LPCWSTR pszPath)
    18331832{
    1834     FIXME("%s\n", debugstr_w(pszPath));
    1835     return FALSE;
     1833        FIXME("%s\n", debugstr_w(pszPath));
     1834        return FALSE;
    18361835}
    18371836
    18381837/*
    1839     ########## special ##########
     1838        ########## special ##########
    18401839*/
    18411840
    … …  
    18461845 *  use PathCompactPath to make sure, the path fits into the control
    18471846 */
    1848 BOOL WINAPI PathSetDlgItemPathA(HWND hDlg, int id, LPCSTR pszPath)
    1849 {   TRACE("%x %x %s\n",hDlg, id, pszPath);
    1850     return SetDlgItemTextA(hDlg, id, pszPath);
     1847BOOL WINAPI PathSetDlgItemPathA(HWND hDlg, int id, LPCSTR pszPath) 
     1848{       TRACE("%x %x %s\n",hDlg, id, pszPath);
     1849        return SetDlgItemTextA(hDlg, id, pszPath);
    18511850}
    18521851
    … …  
    18541853 * PathSetDlgItemPathW   [SHLWAPI.@]
    18551854 */
    1856 BOOL 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 }
     1855BOOL 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}
Note: See TracChangeset for help on using the changeset viewer.