#include "config.h"#include "wine/port.h"#include <stdarg.h>#include <string.h>#include <stdlib.h>#include "wine/unicode.h"#include "windef.h"#include "winbase.h"#include "wingdi.h"#include "winuser.h"#include "winreg.h"#include "winternl.h"#include "shlwapi.h"#include "wine/debug.h"
Include dependency graph for path.c:
Go to the source code of this file.
Classes | |
| struct | envvars_map |
Macros | |
| #define | NO_SHLWAPI_STREAM |
| #define | GET_FUNC(func, module, name, fail) |
| #define | szWebLen (sizeof(szWeb)/sizeof(WCHAR)) |
| #define | szWebMuiLen ((sizeof(szWebMui)+1)/sizeof(WCHAR)) |
| #define | PATH_CHAR_CLASS_LETTER 0x00000001 |
| #define | PATH_CHAR_CLASS_ASTERIX 0x00000002 |
| #define | PATH_CHAR_CLASS_DOT 0x00000004 |
| #define | PATH_CHAR_CLASS_BACKSLASH 0x00000008 |
| #define | PATH_CHAR_CLASS_COLON 0x00000010 |
| #define | PATH_CHAR_CLASS_SEMICOLON 0x00000020 |
| #define | PATH_CHAR_CLASS_COMMA 0x00000040 |
| #define | PATH_CHAR_CLASS_SPACE 0x00000080 |
| #define | PATH_CHAR_CLASS_OTHER_VALID 0x00000100 |
| #define | PATH_CHAR_CLASS_DOUBLEQUOTE 0x00000200 |
| #define | PATH_CHAR_CLASS_INVALID 0x00000000 |
| #define | PATH_CHAR_CLASS_ANY 0xffffffff |
Typedefs | |
| typedef BOOL(WINAPI * | fnpIsNetDrive) (int) |
Variables | |
| static HMODULE | SHLWAPI_hshell32 |
| static fnpIsNetDrive | pIsNetDrive |
| static const WCHAR | allusersprofileW [] = {'%','A','L','L','U','S','E','R','S','P','R','O','F','I','L','E','%',0} |
| static const WCHAR | appdataW [] = {'%','A','P','P','D','A','T','A','%',0} |
| static const WCHAR | programfilesW [] = {'%','P','r','o','g','r','a','m','F','i','l','e','s','%',0} |
| static const WCHAR | systemrootW [] = {'%','S','y','s','t','e','m','R','o','o','t','%',0} |
| static const WCHAR | systemdriveW [] = {'%','S','y','s','t','e','m','D','r','i','v','e','%',0} |
| static const WCHAR | userprofileW [] = {'%','U','S','E','R','P','R','O','F','I','L','E','%',0} |
| static const DWORD | SHELL_charclass [] |
Macro Definition Documentation
◆ GET_FUNC
Value:
do { \
if (!func) { \
if (!func) return fail; \
} \
} while (0)
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
Definition: dbghelp_private.h:377
◆ NO_SHLWAPI_STREAM
◆ PATH_CHAR_CLASS_ANY
◆ PATH_CHAR_CLASS_ASTERIX
◆ PATH_CHAR_CLASS_BACKSLASH
◆ PATH_CHAR_CLASS_COLON
◆ PATH_CHAR_CLASS_COMMA
◆ PATH_CHAR_CLASS_DOT
◆ PATH_CHAR_CLASS_DOUBLEQUOTE
◆ PATH_CHAR_CLASS_INVALID
◆ PATH_CHAR_CLASS_LETTER
◆ PATH_CHAR_CLASS_OTHER_VALID
◆ PATH_CHAR_CLASS_SEMICOLON
◆ PATH_CHAR_CLASS_SPACE
◆ szWebLen
◆ szWebMuiLen
Typedef Documentation
◆ fnpIsNetDrive
Function Documentation
◆ heap_strdupAtoW()
◆ init_envvars_map()
|
static |
Definition at line 4165 of file path.c.
4166{
4168 {
4170 /* exclude null from length */
4172 map++;
4173 }
4174}
DWORD WINAPI ExpandEnvironmentStringsW(IN LPCWSTR lpSrc, IN LPWSTR lpDst, IN DWORD nSize)
Definition: environ.c:519
◆ PathAddBackslashA()
◆ PathAddBackslashW()
◆ PathAddExtensionA()
◆ PathAddExtensionW()
◆ PathAppendA()
◆ PathAppendW()
◆ PathBuildRootA()
Definition at line 329 of file path.c.
330{
332
334 {
336 lpszPath[1] = ':';
337 lpszPath[2] = '\\';
338 lpszPath[3] = '\0';
339 }
340 return lpszPath;
341}
Definition: filesystem.c:103
Referenced by ATL::CPathT< StringType >::PathBuildRootX(), and test_PathBuildRootA().
◆ PathBuildRootW()
Definition at line 348 of file path.c.
349{
351
353 {
355 lpszPath[1] = ':';
356 lpszPath[2] = '\\';
357 lpszPath[3] = '\0';
358 }
359 return lpszPath;
360}
Referenced by IsLFNDriveW(), CDesktopBrowser::OnDeviceChange(), CDrivesFolder::ParseDisplayName(), ATL::CPathT< StringType >::PathBuildRootX(), and PathQualifyExW().
◆ PathCanonicalizeA()
◆ PathCanonicalizeW()
Definition at line 2452 of file path.c.
2453{
2454 LPWSTR lpszDst = lpszBuf;
2455 LPCWSTR lpszSrc = lpszPath;
2456
2458
2459 if (lpszBuf)
2460 *lpszDst = '\0';
2461
2462 if (!lpszBuf || !lpszPath)
2463 {
2466 }
2467
2468 if (!*lpszPath)
2469 {
2470 *lpszBuf++ = '\\';
2471 *lpszBuf = '\0';
2473 }
2474
2475 /* Copy path root */
2476 if (*lpszSrc == '\\')
2477 {
2478 *lpszDst++ = *lpszSrc++;
2479 }
2480 else if (*lpszSrc && lpszSrc[1] == ':')
2481 {
2482 /* X:\ */
2483 *lpszDst++ = *lpszSrc++;
2484 *lpszDst++ = *lpszSrc++;
2485 if (*lpszSrc == '\\')
2486 *lpszDst++ = *lpszSrc++;
2487 }
2488
2489 /* Canonicalize the rest of the path */
2490 while (*lpszSrc)
2491 {
2492 if (*lpszSrc == '.')
2493 {
2494 if (lpszSrc[1] == '\\' && (lpszSrc == lpszPath || lpszSrc[-1] == '\\' || lpszSrc[-1] == ':'))
2495 {
2496 lpszSrc += 2; /* Skip .\ */
2497 }
2498 else if (lpszSrc[1] == '.' && (lpszDst == lpszBuf || lpszDst[-1] == '\\'))
2499 {
2500 /* \.. backs up a directory, over the root if it has no \ following X:.
2501 * .. is ignored if it would remove a UNC server name or initial \\
2502 */
2503 if (lpszDst != lpszBuf)
2504 {
2505 *lpszDst = '\0'; /* Allow PathIsUNCServerShareA test on lpszBuf */
2506 if (lpszDst > lpszBuf+1 && lpszDst[-1] == '\\' &&
2507 (lpszDst[-2] != '\\' || lpszDst > lpszBuf+2))
2508 {
2509 if (lpszDst[-2] == ':' && (lpszDst > lpszBuf+3 || lpszDst[-3] == ':'))
2510 {
2511 lpszDst -= 2;
2512 while (lpszDst > lpszBuf && *lpszDst != '\\')
2513 lpszDst--;
2514 if (*lpszDst == '\\')
2515 lpszDst++; /* Reset to last '\' */
2516 else
2517 lpszDst = lpszBuf; /* Start path again from new root */
2518 }
2520 lpszDst -= 2;
2521 }
2522 while (lpszDst > lpszBuf && *lpszDst != '\\')
2523 lpszDst--;
2524 if (lpszDst == lpszBuf)
2525 {
2526 *lpszDst++ = '\\';
2527 lpszSrc++;
2528 }
2529 }
2530 lpszSrc += 2; /* Skip .. in src path */
2531 }
2532 else
2533 *lpszDst++ = *lpszSrc++;
2534 }
2535 else
2536 *lpszDst++ = *lpszSrc++;
2537 }
2538 /* Append \ to naked drive specs */
2539 if (lpszDst - lpszBuf == 2 && lpszDst[-1] == ':')
2540 *lpszDst++ = '\\';
2541 *lpszDst++ = '\0';
2543}
◆ PathCombineA()
◆ PathCombineW()
Definition at line 194 of file path.c.
195{
198
200
201 /* Invalid parameters */
204 if (!lpszDir && !lpszFile)
205 {
206 lpszDest[0] = 0;
208 }
209
210 if ((!lpszFile || !*lpszFile) && lpszDir)
211 {
212 /* Use dir only */
214 }
216 {
218 {
219 /* Use file only */
221 }
222 else
223 {
224 bUseBoth = TRUE;
225 bStrip = TRUE;
226 }
227 }
228 else
229 bUseBoth = TRUE;
230
231 if (bUseBoth)
232 {
234 if (bStrip)
235 {
236 PathStripToRootW(szTemp);
237 lpszFile++; /* Skip '\' */
238 }
240 {
241 lpszDest[0] = 0;
243 }
244 strcatW(szTemp, lpszFile);
245 }
246
249}
◆ PathCommonPrefixA()
Definition at line 2757 of file path.c.
2758{
2759 size_t iLen = 0;
2760 LPCSTR lpszIter1 = lpszFile1;
2761 LPCSTR lpszIter2 = lpszFile2;
2762
2764
2765 if (achPath)
2766 *achPath = '\0';
2767
2768 if (!lpszFile1 || !lpszFile2)
2769 return 0;
2770
2771 /* Handle roots first */
2773 {
2775 return 0;
2776 lpszIter1 += 2;
2777 lpszIter2 += 2;
2778 }
2780 return 0; /* Know already lpszFile1 is not UNC */
2781
2782 do
2783 {
2784 /* Update len */
2785 if ((!*lpszIter1 || *lpszIter1 == '\\') &&
2786 (!*lpszIter2 || *lpszIter2 == '\\'))
2787 iLen = lpszIter1 - lpszFile1; /* Common to this point */
2788
2790 break; /* Strings differ at this point */
2791
2792 lpszIter1++;
2793 lpszIter2++;
2794 } while (1);
2795
2796 if (iLen == 2)
2797 iLen++; /* Feature/Bug compatible with Win32 */
2798
2799 if (iLen && achPath)
2800 {
2801 memcpy(achPath,lpszFile1,iLen);
2802 achPath[iLen] = '\0';
2803 }
2804 return iLen;
2805}
◆ PathCommonPrefixW()
Definition at line 2812 of file path.c.
2813{
2814 size_t iLen = 0;
2815 LPCWSTR lpszIter1 = lpszFile1;
2816 LPCWSTR lpszIter2 = lpszFile2;
2817
2819
2820 if (achPath)
2821 *achPath = '\0';
2822
2823 if (!lpszFile1 || !lpszFile2)
2824 return 0;
2825
2826 /* Handle roots first */
2828 {
2830 return 0;
2831 lpszIter1 += 2;
2832 lpszIter2 += 2;
2833 }
2835 return 0; /* Know already lpszFile1 is not UNC */
2836
2837 do
2838 {
2839 /* Update len */
2840 if ((!*lpszIter1 || *lpszIter1 == '\\') &&
2841 (!*lpszIter2 || *lpszIter2 == '\\'))
2842 iLen = lpszIter1 - lpszFile1; /* Common to this point */
2843
2845 break; /* Strings differ at this point */
2846
2847 lpszIter1++;
2848 lpszIter2++;
2849 } while (1);
2850
2851 if (iLen == 2)
2852 iLen++; /* Feature/Bug compatible with Win32 */
2853
2854 if (iLen && achPath)
2855 {
2857 achPath[iLen] = '\0';
2858 }
2859 return iLen;
2860}
◆ PathCompactPathA()
Definition at line 2876 of file path.c.
2877{
2879
2881
2882 if (lpszPath)
2883 {
2888 }
2889 return bRet;
2890}
BOOL WINAPI PathCompactPathW(HDC hDC, LPWSTR lpszPath, UINT dx)
Definition: path.c:2897
Referenced by ATL::CPathT< StringType >::PathCompactPathX().
◆ PathCompactPathExA()
Definition at line 1441 of file path.c.
1443{
1445
1447
1449 {
1452
1454 szDest[0] = '\0';
1457 }
1458 return bRet;
1459}
BOOL WINAPI PathCompactPathExW(LPWSTR lpszDest, LPCWSTR lpszPath, UINT cchMax, DWORD dwFlags)
Definition: path.c:1466
Referenced by ATL::CPathT< StringType >::PathCompactPathExX().
◆ PathCompactPathExW()
Definition at line 1466 of file path.c.
1468{
1470 LPCWSTR lpszFile;
1471 DWORD dwLen, dwFileLen = 0;
1472
1474
1475 if (!lpszPath)
1477
1479 {
1482 }
1483
1485
1488
1489 dwLen = strlenW(lpszPath) + 1;
1490
1492 {
1493 /* Don't need to compact */
1496 }
1497
1498 /* Path must be compacted to fit into lpszDest */
1499 lpszFile = PathFindFileNameW(lpszPath);
1500 dwFileLen = lpszPath + dwLen - lpszFile;
1501
1502 if (dwFileLen == dwLen)
1503 {
1504 /* No root in psth */
1506 {
1511 }
1512 /* Compact the file name with ellipses at the end */
1513 cchMax -= 4;
1517 }
1518 /* We have a root in the path */
1519 lpszFile--; /* Start compacted filename with the path separator */
1520 dwFileLen++;
1521
1523 {
1524 /* Compact the file name */
1526 {
1531 }
1533 lpszDest += 3;
1534 cchMax -= 4;
1535 *lpszDest++ = *lpszFile++;
1537 {
1542 }
1543 cchMax -= 4;
1547 }
1548
1549 /* Only the root needs to be Compacted */
1550 dwLen = cchMax - dwFileLen - 3;
1555}
Referenced by PathCompactPathExA(), and ATL::CPathT< StringType >::PathCompactPathExX().
◆ PathCompactPathW()
Definition at line 2897 of file path.c.
2898{
2904 DWORD dwLen;
2905
2907
2908 if (!lpszPath)
2910
2913
2914 /* Get the length of the whole path */
2915 dwLen = strlenW(lpszPath);
2917
2919 {
2920 /* Path too big, must reduce it */
2921 LPWSTR sFile;
2922 DWORD dwEllipsesLen = 0, dwPathLen = 0;
2923
2924 sFile = PathFindFileNameW(lpszPath);
2925 if (sFile != lpszPath) sFile--;
2926
2927 /* Get the size of ellipses */
2929 dwEllipsesLen = size.cx;
2930 /* Get the size of the file name */
2932 dwPathLen = size.cx;
2933
2934 if (sFile != lpszPath)
2935 {
2936 LPWSTR sPath = sFile;
2938
2939 /* The path includes a file name. Include as much of the path prior to
2940 * the file name as possible, allowing for the ellipses, e.g:
2941 * c:\some very long path\filename ==> c:\some v...\filename
2942 */
2944
2945 do
2946 {
2947 DWORD dwTotalLen = bEllipses? dwPathLen + dwEllipsesLen : dwPathLen;
2948
2950 dwTotalLen += size.cx;
2952 break;
2953 sPath--;
2954 if (!bEllipses)
2955 {
2956 bEllipses = TRUE;
2957 sPath -= 2;
2958 }
2959 } while (sPath > lpszPath);
2960
2961 if (sPath > lpszPath)
2962 {
2963 if (bEllipses)
2964 {
2965 strcpyW(sPath, szEllipses);
2967 }
2968 bRet = TRUE;
2970 }
2971 strcpyW(lpszPath, szEllipses);
2973 bRet = FALSE;
2975 }
2976
2977 /* Trim the path by adding ellipses to the end, e.g:
2978 * A very long file name.txt ==> A very...
2979 */
2980 dwLen = strlenW(lpszPath);
2981
2983 dwLen = MAX_PATH - 3;
2985
2986 do {
2987 dwLen--;
2990
2991 if (!dwLen)
2992 {
2993 DWORD dwWritten = 0;
2994
2995 dwEllipsesLen /= 3; /* Size of a single '.' */
2996
2997 /* Write as much of the Ellipses string as possible */
2999 {
3000 *lpszPath++ = '.';
3001 dwWritten += dwEllipsesLen;
3002 dwLen++;
3003 }
3004 *lpszPath = '\0';
3005 bRet = FALSE;
3006 }
3007 else
3008 {
3011 }
3012 }
3013
3014end:
3017
3018 return bRet;
3019}
Definition: kdterminal.h:26
BOOL WINAPI GetTextExtentPointW(_In_ HDC hdc, _In_reads_(c) LPCWSTR lpString, _In_ int c, _Out_ LPSIZE lpsz)
int WINAPI ReleaseDC(_In_opt_ HWND, _In_ HDC)
HDC WINAPI GetDC(_In_opt_ HWND)
Referenced by CZipExtract::CCompleteSettingsPage::OnSetActive(), PathCompactPathA(), ATL::CPathT< StringType >::PathCompactPathX(), and PathSetDlgItemPathW().
◆ PathCreateFromUrlA()
| HRESULT WINAPI PathCreateFromUrlA | ( | LPCSTR | pszUrl, |
| LPSTR | pszPath, | ||
| LPDWORD | pcchPath, | ||
| DWORD | dwReserved | ||
| ) |
Definition at line 3312 of file path.c.
3314{
3316 WCHAR *pathW = bufW;
3317 UNICODE_STRING urlW;
3320
3323
3329 }
3334 pszPath[lenA] = 0;
3335 *pcchPath = lenA;
3336 } else {
3337 *pcchPath = lenA + 1;
3339 }
3340 }
3342 RtlFreeUnicodeString(&urlW);
3344}
HRESULT WINAPI PathCreateFromUrlW(const WCHAR *url, WCHAR *path, DWORD *pcchPath, DWORD dwReserved)
Definition: path.c:3073
Definition: mshtmhst.idl:286
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED _In_opt_ LPTRANSMIT_FILE_BUFFERS _In_ DWORD dwReserved
Definition: mswsock.h:95
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
_Use_decl_annotations_ NTSTATUS NTAPI RtlUnicodeToMultiByteN(_Out_ PCHAR MbString, _In_ ULONG MbSize, _Out_opt_ PULONG ResultSize, _In_ PCWCH UnicodeString, _In_ ULONG UnicodeSize)
Definition: nlsboot.c:107
_Use_decl_annotations_ NTSTATUS NTAPI RtlUnicodeToMultiByteSize(_Out_ PULONG MbSize, _In_ PCWCH UnicodeString, _In_ ULONG UnicodeSize)
Definition: nlsboot.c:145
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
Definition: env_spec_w32.h:368
◆ PathCreateFromUrlAlloc()
◆ PathCreateFromUrlW()
| HRESULT WINAPI PathCreateFromUrlW | ( | LPCWSTR | pszUrl, |
| LPWSTR | pszPath, | ||
| LPDWORD | pcchPath, | ||
| DWORD | dwReserved | ||
| ) |
Definition at line 3361 of file path.c.
3363{
3370
3372
3375
3378
3380 file_colon, 5) != CSTR_EQUAL)
3382 pszUrl += 5;
3384
3385 src = pszUrl;
3386 nslashes = 0;
3388 nslashes++;
3389 src++;
3390 }
3391
3392 /* We need a temporary buffer so we can compute what size to ask for.
3393 * We know that the final string won't be longer than the current pszUrl
3394 * plus at most two backslashes. All the other transformations make it
3395 * shorter.
3396 */
3400 else
3401 tpath = pszPath;
3402
3403 len = 0;
3404 dst = tpath;
3405 unescape = 1;
3406 switch (nslashes)
3407 {
3408 case 0:
3409 /* 'file:' + escaped DOS path */
3410 break;
3411 case 1:
3412 /* 'file:/' + escaped DOS path */
3413 /* fall through */
3414 case 3:
3415 /* 'file:///' (implied localhost) + escaped DOS path */
3417 src -= 1;
3418 break;
3419 case 2:
3422 {
3423 /* 'file://localhost/' + escaped DOS path */
3424 src += 10;
3425 }
3427 {
3428 /* 'file://' + unescaped DOS path */
3429 unescape = 0;
3430 }
3431 else
3432 {
3433 /* 'file://hostname:port/path' (where path is escaped)
3434 * or 'file:' + escaped UNC path (\\server\share\path)
3435 * The second form is clearly specific to Windows and it might
3436 * even be doing a network lookup to try to figure it out.
3437 */
3439 src++;
3444 {
3445 /* 'Forget' to add a trailing '/', just like Windows */
3446 src++;
3447 }
3448 }
3449 break;
3450 case 4:
3451 /* 'file://' + unescaped UNC path (\\server\share\path) */
3452 unescape = 0;
3454 break;
3455 /* fall through */
3456 default:
3457 /* 'file:/...' + escaped UNC path (\\server\share\path) */
3458 src -= 2;
3459 }
3460
3461 /* Copy the remainder of the path */
3464
3465 /* First do the Windows-specific path conversions */
3469 tpath[1] = ':'; /* c| -> c: */
3470
3471 /* And only then unescape the path (i.e. escaped slashes are left as is) */
3473 {
3476 {
3477 /* When working in-place UrlUnescapeW() does not set len */
3479 }
3480 }
3481
3483 {
3486 }
3487 else
3488 {
3490 if (tpath != pszPath)
3491 StrCpyW(pszPath, tpath);
3492 }
3493 if (tpath != pszPath)
3495
3498}
INT WINAPI CompareStringW(LCID lcid, DWORD flags, LPCWSTR str1, INT len1, LPCWSTR str2, INT len2)
Definition: locale.c:4017
HRESULT WINAPI UrlUnescapeW(WCHAR *url, WCHAR *unescaped, DWORD *unescaped_len, DWORD flags)
Definition: path.c:2936
#define LOCALE_INVARIANT
◆ PathFileExistsA()
Definition at line 1761 of file path.c.
1762{
1763 UINT iPrevErrMode;
1764 DWORD dwAttr;
1765
1767
1768 if (!lpszPath)
1770
1771 /* Prevent a dialog box if path is on a disk that has been ejected. */
1773 dwAttr = GetFileAttributesA(lpszPath);
1774 SetErrorMode(iPrevErrMode);
1776}
◆ PathFileExistsAndAttributesA()
Definition at line 1812 of file path.c.
1813{
1814 UINT iPrevErrMode;
1815 DWORD dwVal = 0;
1816
1818
1819 if (dwAttr)
1820 *dwAttr = INVALID_FILE_ATTRIBUTES;
1821
1822 if (!lpszPath)
1824
1826 dwVal = GetFileAttributesA(lpszPath);
1827 SetErrorMode(iPrevErrMode);
1828 if (dwAttr)
1829 *dwAttr = dwVal;
1831}
◆ PathFileExistsAndAttributesW()
Definition at line 1838 of file path.c.
1839{
1840 UINT iPrevErrMode;
1841 DWORD dwVal;
1842
1844
1845 if (!lpszPath)
1847
1849 dwVal = GetFileAttributesW(lpszPath);
1850 SetErrorMode(iPrevErrMode);
1851 if (dwAttr)
1852 *dwAttr = dwVal;
1854}
Referenced by GetTypeDescriptionByPath(), PathFileExistsDefExtAndAttributesW(), and PathResolveW().
◆ PathFileExistsDefExtA()
Definition at line 1201 of file path.c.
1202{
1204
1206
1207 if (lpszPath)
1208 {
1212 if (bRet)
1214 }
1215 return bRet;
1216}
BOOL WINAPI PathFileExistsDefExtW(LPWSTR lpszPath, DWORD dwWhich)
Definition: path.c:1123
◆ PathFileExistsDefExtW()
Definition at line 1123 of file path.c.
1124{
1126 { '.', 'c', 'o', 'm', 0},
1127 { '.', 'e', 'x', 'e', 0},
1128 { '.', 'b', 'a', 't', 0},
1129 { '.', 'l', 'n', 'k', 0},
1130 { '.', 'c', 'm', 'd', 0},
1131 { 0, 0, 0, 0, 0} };
1132
1134
1137
1138 if (dwWhich)
1139 {
1141#ifndef __REACTOS__
1142 if (!*szExt || dwWhich & 0x40)
1143#else
1145#endif
1146 {
1147 size_t iChoose = 0;
1151#ifndef __REACTOS__
1152 while ( (dwWhich & 0x1) && pszExts[iChoose][0] )
1153#else
1154 while (pszExts[iChoose][0])
1155#endif
1156 {
1157#ifdef __REACTOS__
1158 if (dwWhich & 0x1)
1159 {
1161#endif
1162 lstrcpyW(lpszPath + iLen, pszExts[iChoose]);
1165#ifdef __REACTOS__
1166 }
1167#endif
1168 iChoose++;
1169 dwWhich >>= 1;
1170 }
1173 }
1174 }
1176}
Referenced by PathFileExistsDefExtA(), PathFileExistsDefExtAndAttributesW(), PathFindOnPathExA(), PathFindOnPathExW(), PathSearchOnExtensionsW(), and SHLWAPI_PathFindInOtherDirs().
◆ PathFileExistsW()
Definition at line 1783 of file path.c.
1784{
1785 UINT iPrevErrMode;
1786 DWORD dwAttr;
1787
1789
1790 if (!lpszPath)
1792
1794 dwAttr = GetFileAttributesW(lpszPath);
1795 SetErrorMode(iPrevErrMode);
1797}
◆ PathFindExtensionA()
◆ PathFindExtensionW()
◆ PathFindFileNameA()
◆ PathFindFileNameW()
Definition at line 394 of file path.c.
395{
396 LPCWSTR lastSlash = lpszPath;
397
399
400 while (lpszPath && *lpszPath)
401 {
402 if ((*lpszPath == '\\' || *lpszPath == '/' || *lpszPath == ':') &&
403 lpszPath[1] && lpszPath[1] != '\\' && lpszPath[1] != '/')
404 lastSlash = lpszPath + 1;
405 lpszPath++;
406 }
408}
◆ PathFindNextComponentA()
◆ PathFindNextComponentW()
◆ PathFindOnPathA()
Definition at line 1398 of file path.c.
1399{
1402 }
BOOL WINAPI PathFindOnPathExA(LPSTR lpszFile, LPCSTR *lppszOtherDirs, DWORD dwWhich)
Definition: path.c:1313
◆ PathFindOnPathExA()
Definition at line 1313 of file path.c.
1314{
1317
1319
1322
1324
1325 /* Search provided directories first */
1326 if (lppszOtherDirs && *lppszOtherDirs)
1327 {
1329 LPCSTR *lpszOtherPath = lppszOtherDirs;
1330
1331 while (lpszOtherPath && *lpszOtherPath && (*lpszOtherPath)[0])
1332 {
1336 {
1339 }
1340 lpszOtherPath++;
1341 }
1342 }
1343 /* Not found, try system and path dirs */
1345 {
1348 }
1350}
static BOOL SHLWAPI_PathFindInOtherDirs(LPWSTR lpszFile, DWORD dwWhich)
Definition: path.c:1223
Referenced by PathFindOnPathA().
◆ PathFindOnPathExW()
Definition at line 1357 of file path.c.
1358{
1360
1362
1365
1366 /* Search provided directories first */
1367 if (lppszOtherDirs && *lppszOtherDirs)
1368 {
1369 LPCWSTR *lpszOtherPath = lppszOtherDirs;
1370 while (lpszOtherPath && *lpszOtherPath && (*lpszOtherPath)[0])
1371 {
1374 {
1377 }
1378 lpszOtherPath++;
1379 }
1380 }
1381 /* Not found, try system and path dirs */
1383}
Referenced by PathFindOnPathW(), PathSearchOnExtensionsW(), ShellExecCmdLine(), and WelcomeDlgProc().
◆ PathFindOnPathW()
Definition at line 1409 of file path.c.
1410{
1413}
BOOL WINAPI PathFindOnPathExW(LPWSTR lpszFile, LPCWSTR *lppszOtherDirs, DWORD dwWhich)
Definition: path.c:1357
Referenced by DoEntry(), PathResolveW(), and SHELL_FindExecutable().
◆ PathFindSuffixArrayA()
Definition at line 3999 of file path.c.
4000{
4001 size_t dwLen;
4002 int dwRet = 0;
4003
4005
4006 if (lpszSuffix && lppszArray && dwCount > 0)
4007 {
4008 dwLen = strlen(lpszSuffix);
4009
4010 while (dwRet < dwCount)
4011 {
4013 if (dwCompareLen < dwLen)
4014 {
4016 return *lppszArray; /* Found */
4017 }
4018 dwRet++;
4019 lppszArray++;
4020 }
4021 }
4023}
◆ PathFindSuffixArrayW()
Definition at line 4030 of file path.c.
4031{
4032 size_t dwLen;
4033 int dwRet = 0;
4034
4036
4037 if (lpszSuffix && lppszArray && dwCount > 0)
4038 {
4039 dwLen = strlenW(lpszSuffix);
4040
4041 while (dwRet < dwCount)
4042 {
4044 if (dwCompareLen < dwLen)
4045 {
4047 return *lppszArray; /* Found */
4048 }
4049 dwRet++;
4050 lppszArray++;
4051 }
4052 }
4054}
◆ PathGetArgsA()
◆ PathGetArgsW()
◆ PathGetCharTypeA()
◆ PathGetCharTypeW()
Definition at line 3042 of file path.c.
3043{
3045
3047
3048 if (!ch || ch < ' ' || ch == '<' || ch == '>' ||
3049 ch == '"' || ch == '|' || ch == '/')
3051 else if (ch == '*' || ch=='?')
3053 else if ((ch == '\\') || (ch == ':'))
3055 else
3056 {
3057 if (ch < 126)
3058 {
3060 ch == '.' || ch == '@' || ch == '^' ||
3061 ch == '\'' || ch == 130 || ch == '`')
3063 }
3064 else
3067 }
3069}
_Check_return_ _CRTIMP int __cdecl isalnum(_In_ int _C)
◆ PathGetDriveNumberA()
◆ PathGetDriveNumberW()
Definition at line 553 of file path.c.
554{
556
558
560
562 return -1;
563
565 path += 4;
566
569 return -1;
570
572}
Definition: wbemprox_private.h:188
◆ PathIsContentTypeA()
Definition at line 2064 of file path.c.
2065{
2066 LPCSTR szExt;
2067 DWORD dwDummy;
2069
2071
2074 REG_NONE, szBuff, &dwDummy) &&
2075 !strcasecmp(lpszContentType, szBuff))
2076 {
2078 }
2080}
DWORD WINAPI SHGetValueA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
Definition: reg.c:1207
◆ PathIsContentTypeW()
Definition at line 2087 of file path.c.
2088{
2090 LPCWSTR szExt;
2091 DWORD dwDummy;
2093
2095
2098 REG_NONE, szBuff, &dwDummy) &&
2099 !strcmpiW(lpszContentType, szBuff))
2100 {
2102 }
2104}
DWORD WINAPI SHGetValueW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
Definition: reg.c:1236
◆ PathIsDirectoryA()
Definition at line 1704 of file path.c.
Referenced by ATL::CPathT< StringType >::PathIsDirectoryX().
◆ PathIsDirectoryEmptyA()
◆ PathIsDirectoryEmptyW()
Definition at line 3937 of file path.c.
3938{
3941 DWORD dwLen;
3942 HANDLE hfind;
3945
3947
3950
3952 PathAddBackslashW(szSearch);
3953 dwLen = strlenW(szSearch);
3956
3957 strcpyW(szSearch + dwLen, szAllFiles);
3961
3962 do
3963 {
3965 {
3968 }
3969
3970 retVal = FALSE;
3971 break;
3972 }
3974
3975 FindClose(hfind);
3976 return retVal;
3977}
static int find_data(const struct Vector *v, const BYTE *pData, int size)
Definition: filtermapper.c:162
HANDLE WINAPI FindFirstFileW(IN LPCWSTR lpFileName, OUT LPWIN32_FIND_DATAW lpFindFileData)
Definition: find.c:320
BOOL WINAPI FindNextFileW(IN HANDLE hFindFile, OUT LPWIN32_FIND_DATAW lpFindFileData)
Definition: find.c:382
Definition: nsiface.idl:2307
Definition: minwinbase.h:282
Referenced by move_dir_to_dir(), and PathIsDirectoryEmptyA().
◆ PathIsDirectoryW()
Definition at line 1729 of file path.c.
Referenced by CDirectoryList::AddPathsFromDirectory(), BrFolder_OnOK(), copy_file(), create_target_directory(), CreateDirectoryWatcherFromRegEntry(), DetermineDialogBoxType(), CAppScrnshotPreview::DisplayImage(), DoAddFilesFromItem(), DoBuildFilesAndDirs(), DoTestEntry(), CDeskLinkDropHandler::Drop(), CAddressEditBox::ExecuteCommandLine(), FILEDLG95_InitControls(), CFSFolder::GetCustomViewInfo(), getIconLocationForFolder(), CFileDefExt::Initialize(), InstallFontFiles(), PathIsDirectoryEmptyW(), ATL::CPathT< StringType >::PathIsDirectoryX(), CDirectoryWatcher::ProcessNotification(), SHAddToRecentDocs(), SHELL_execute(), SHExplorerParseCmdLine(), ShowCreateShortcutWizard(), WindowProc(), and wWinMain().
◆ PathIsFileSpecA()
◆ PathIsFileSpecW()
◆ PathIsLFNFileSpecA()
Definition at line 3828 of file path.c.
3829{
3830 DWORD dwNameLen = 0, dwExtLen = 0;
3831
3833
3834 if (!lpszPath)
3836
3837 while (*lpszPath)
3838 {
3839 if (*lpszPath == ' ')
3841 if (*lpszPath == '.')
3842 {
3843 if (dwExtLen)
3845 dwExtLen = 1;
3846 }
3847 else if (dwExtLen)
3848 {
3849 dwExtLen++;
3850 if (dwExtLen > 4)
3852 }
3853 else
3854 {
3855 dwNameLen++;
3856 if (dwNameLen > 8)
3858 }
3859 lpszPath += IsDBCSLeadByte(*lpszPath) ? 2 : 1;
3860 }
3862}
◆ PathIsLFNFileSpecW()
Definition at line 3869 of file path.c.
3870{
3871 DWORD dwNameLen = 0, dwExtLen = 0;
3872
3874
3875 if (!lpszPath)
3877
3878 while (*lpszPath)
3879 {
3880 if (*lpszPath == ' ')
3882 if (*lpszPath == '.')
3883 {
3884 if (dwExtLen)
3886 dwExtLen = 1;
3887 }
3888 else if (dwExtLen)
3889 {
3890 dwExtLen++;
3891 if (dwExtLen > 4)
3893 }
3894 else
3895 {
3896 dwNameLen++;
3897 if (dwNameLen > 8)
3899 }
3900 lpszPath++;
3901 }
3903}
◆ PathIsNetworkPathA()
Definition at line 3769 of file path.c.
3770{
3771 int dwDriveNum;
3772
3774
3775 if (!lpszPath)
3777 if (*lpszPath == '\\' && lpszPath[1] == '\\')
3779 dwDriveNum = PathGetDriveNumberA(lpszPath);
3780 if (dwDriveNum == -1)
3782#ifdef __REACTOS__
3784#else
3787#endif
3788}
◆ PathIsNetworkPathW()
Definition at line 3795 of file path.c.
3796{
3797 int dwDriveNum;
3798
3800
3801 if (!lpszPath)
3803 if (*lpszPath == '\\' && lpszPath[1] == '\\')
3805 dwDriveNum = PathGetDriveNumberW(lpszPath);
3806 if (dwDriveNum == -1)
3808#ifdef __REACTOS__
3810#else
3813#endif
3814}
◆ PathIsPrefixA()
Definition at line 2168 of file path.c.
2169{
2171
2172 if (lpszPrefix && lpszPath &&
2176}
int WINAPI PathCommonPrefixA(const char *file1, const char *file2, char *path)
Definition: path.c:1570
◆ PathIsPrefixW()
Definition at line 2183 of file path.c.
2184{
2186
2187 if (lpszPrefix && lpszPath &&
2191}
int WINAPI PathCommonPrefixW(const WCHAR *file1, const WCHAR *file2, WCHAR *path)
Definition: path.c:1620
◆ PathIsRelativeA()
◆ PathIsRelativeW()
◆ PathIsRootA()
Definition at line 1608 of file path.c.
1609{
1611
1612 if (lpszPath && *lpszPath)
1613 {
1614 if (*lpszPath == '\\')
1615 {
1616 if (!lpszPath[1])
1618 else if (lpszPath[1]=='\\')
1619 {
1621 lpszPath += 2;
1622
1623 /* Check for UNC root path */
1624 while (*lpszPath)
1625 {
1626 if (*lpszPath == '\\')
1627 {
1628 if (bSeenSlash)
1630 bSeenSlash = TRUE;
1631 }
1632 lpszPath = CharNextA(lpszPath);
1633 }
1635 }
1636 }
1637 else if (lpszPath[1] == ':' && lpszPath[2] == '\\' && lpszPath[3] == '\0')
1639 }
1641}
◆ PathIsRootW()
Definition at line 1648 of file path.c.
1649{
1651
1652 if (lpszPath && *lpszPath)
1653 {
1654 if (*lpszPath == '\\')
1655 {
1656 if (!lpszPath[1])
1658 else if (lpszPath[1]=='\\')
1659 {
1661 lpszPath += 2;
1662
1663 /* Check for UNC root path */
1664 while (*lpszPath)
1665 {
1666 if (*lpszPath == '\\')
1667 {
1668 if (bSeenSlash)
1670 bSeenSlash = TRUE;
1671 }
1672 lpszPath++;
1673 }
1675 }
1676 }
1677 else if (lpszPath[1] == ':' && lpszPath[2] == '\\' && lpszPath[3] == '\0')
1679 }
1681}
◆ PathIsSameRootA()
◆ PathIsSameRootW()
◆ PathIsSystemFolderA()
◆ PathIsSystemFolderW()
Definition at line 2224 of file path.c.
Referenced by CViewStatePropertyBag::_IsSystemFolder().
◆ PathIsUNCA()
Definition at line 2249 of file path.c.
2250{
2252
2253/*
2254 * On Windows 2003, tests show that strings starting with "\\?" are
2255 * considered UNC, while on Windows Vista+ this is not the case anymore.
2256 */
2257// #ifdef __REACTOS__
2258#if (_WIN32_WINNT >= _WIN32_WINNT_VISTA)
2259 if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\') && (lpszPath[2]!='?'))
2260#else
2261 if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'))
2262#endif
2265}
◆ PathIsUNCServerA()
◆ PathIsUNCServerShareA()
◆ PathIsUNCServerShareW()
Definition at line 2384 of file path.c.
2385{
2387
2388 if (lpszPath && *lpszPath++ == '\\' && *lpszPath++ == '\\')
2389 {
2391 while (*lpszPath)
2392 {
2393 if (*lpszPath == '\\')
2394 {
2395 if (bSeenSlash)
2397 bSeenSlash = TRUE;
2398 }
2399 lpszPath++;
2400 }
2401 return bSeenSlash;
2402 }
2404}
◆ PathIsUNCServerW()
◆ PathIsUNCW()
Definition at line 2272 of file path.c.
2273{
2275
2276/*
2277 * On Windows 2003, tests show that strings starting with "\\?" are
2278 * considered UNC, while on Windows Vista+ this is not the case anymore.
2279 */
2280// #ifdef __REACTOS__
2281#if (_WIN32_WINNT >= _WIN32_WINNT_VISTA)
2282 if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\') && (lpszPath[2]!='?'))
2283#else
2284 if (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'))
2285#endif
2288}
◆ PathIsValidCharA()
◆ PathIsValidCharW()
◆ PathMakePrettyA()
Definition at line 2674 of file path.c.
2675{
2676 LPSTR pszIter = lpszPath;
2677
2679
2680 if (!pszIter)
2682
2683 if (*pszIter)
2684 {
2685 do
2686 {
2689 pszIter++;
2690 } while (*pszIter);
2691 pszIter = lpszPath + 1;
2692 while (*pszIter)
2693 {
2694 *pszIter = tolower(*pszIter);
2695 pszIter++;
2696 }
2697 }
2699}
Referenced by ATL::CPathT< StringType >::PathMakePrettyX(), and test_PathMakePretty().
◆ PathMakePrettyW()
Definition at line 2706 of file path.c.
2707{
2708 LPWSTR pszIter = lpszPath;
2709
2711
2712 if (!pszIter)
2714
2715 if (*pszIter)
2716 {
2717 do
2718 {
2721 pszIter++;
2722 } while (*pszIter);
2723 pszIter = lpszPath + 1;
2724 while (*pszIter)
2725 {
2726 *pszIter = tolowerW(*pszIter);
2727 pszIter++;
2728 }
2729 }
2731}
Referenced by ATL::CPathT< StringType >::PathMakePrettyX().
◆ PathMakeSystemFolderA()
◆ PathMakeSystemFolderW()
Definition at line 3126 of file path.c.
3127{
3130
3132
3133 if (!lpszPath || !*lpszPath)
3135
3136 /* If the directory is already a system directory, don't do anything */
3140
3144
3145 /* "UseSystemForSystemFolders" Tells Win what attributes to use */
3147 dwDefaultAttr = FILE_ATTRIBUTE_SYSTEM;
3148
3151
3152 /* Change file attributes to system attributes */
3155}
BOOL WINAPI SetFileAttributesW(LPCWSTR lpFileName, DWORD dwFileAttributes)
Definition: fileinfo.c:794
UINT WINAPI GetSystemDirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2313
UINT WINAPI GetWindowsDirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2352
static BOOL SHLWAPI_UseSystemForSystemFolders(void)
Definition: path.c:3076
Referenced by PathMakeSystemFolderA(), and SHCreatePropertyBagOnProfileSection().
◆ PathMatchSingleMaskA()
Definition at line 1859 of file path.c.
1860{
1862 {
1864 {
1865 do
1866 {
1871 }
1872
1875
1878 }
1879
1881 {
1883 mask++;
1886 }
1888}
static BOOL PathMatchSingleMaskA(LPCSTR name, LPCSTR mask)
Definition: path.c:1859
Referenced by PathMatchSingleMaskA(), and PathMatchSpecA().
◆ PathMatchSingleMaskW()
Definition at line 1893 of file path.c.
1894{
1896 {
1898 {
1899 do
1900 {
1905 }
1906
1909
1910 name++;
1911 mask++;
1912 }
1914 {
1916 mask++;
1919 }
1921}
static BOOL PathMatchSingleMaskW(LPCWSTR name, LPCWSTR mask)
Definition: path.c:1893
Referenced by PathMatchSingleMaskW(), and PathMatchSpecW().
◆ PathMatchSpecA()
◆ PathMatchSpecW()
Definition at line 1970 of file path.c.
1971{
1973
1975
1978
1979 while (*lpszMask)
1980 {
1981 while (*lpszMask == ' ')
1982 lpszMask++; /* Eat leading spaces */
1983
1986
1987 while (*lpszMask && *lpszMask != ';')
1988 lpszMask++; /* masks separated by ';' */
1989
1990 if (*lpszMask == ';')
1991 lpszMask++;
1992 }
1994}
◆ PathParseIconLocationA()
Definition at line 1073 of file path.c.
1074{
1075 int iRet = 0;
1076 LPSTR lpszComma;
1077
1079
1080 if (lpszPath)
1081 {
1083 {
1084 *lpszComma++ = '\0';
1085 iRet = StrToIntA(lpszComma);
1086 }
1087 PathUnquoteSpacesA(lpszPath);
1088 PathRemoveBlanksA(lpszPath);
1089 }
1090 return iRet;
1091}
◆ PathParseIconLocationW()
Definition at line 1098 of file path.c.
1099{
1100 int iRet = 0;
1101 LPWSTR lpszComma;
1102
1104
1105 if (lpszPath)
1106 {
1108 {
1109 *lpszComma++ = '\0';
1110 iRet = StrToIntW(lpszComma);
1111 }
1112 PathUnquoteSpacesW(lpszPath);
1113 PathRemoveBlanksW(lpszPath);
1114 }
1115 return iRet;
1116}
◆ PathQuoteSpacesA()
◆ PathQuoteSpacesW()
◆ PathRelativePathToA()
| BOOL WINAPI PathRelativePathToA | ( | LPSTR | lpszPath, |
| LPCSTR | lpszFrom, | ||
| DWORD | dwAttrFrom, | ||
| LPCSTR | lpszTo, | ||
| DWORD | dwAttrTo | ||
| ) |
Definition at line 3552 of file path.c.
3554{
3556
3558 dwAttrFrom, debugstr_a(lpszTo), dwAttrTo);
3559
3560 if(lpszPath && lpszFrom && lpszTo)
3561 {
3569 }
3570 return bRet;
3571}
BOOL WINAPI PathRelativePathToW(WCHAR *path, const WCHAR *from, DWORD attributes_from, const WCHAR *to, DWORD attributes_to)
Definition: path.c:2376
◆ PathRelativePathToW()
| BOOL WINAPI PathRelativePathToW | ( | LPWSTR | lpszPath, |
| LPCWSTR | lpszFrom, | ||
| DWORD | dwAttrFrom, | ||
| LPCWSTR | lpszTo, | ||
| DWORD | dwAttrTo | ||
| ) |
Definition at line 3578 of file path.c.
3580{
3585 DWORD dwLen;
3586
3588 dwAttrFrom, debugstr_w(lpszTo), dwAttrTo);
3589
3590 if(!lpszPath || !lpszFrom || !lpszTo)
3592
3593 *lpszPath = '\0';
3596
3598 PathRemoveFileSpecW(szFrom);
3600 PathRemoveFileSpecW(szTo);
3601
3602 /* Paths can only be relative if they have a common root */
3605
3606 /* Strip off lpszFrom components to the root, by adding "..\" */
3607 lpszFrom = szFrom + dwLen;
3608 if (!*lpszFrom)
3609 {
3610 lpszPath[0] = '.';
3611 lpszPath[1] = '\0';
3612 }
3613 if (*lpszFrom == '\\')
3614 lpszFrom++;
3615
3616 while (*lpszFrom)
3617 {
3618 lpszFrom = PathFindNextComponentW(lpszFrom);
3619 strcatW(lpszPath, *lpszFrom ? szPrevDirSlash : szPrevDir);
3620 }
3621
3622 /* From the root add the components of lpszTo */
3623 lpszTo += dwLen;
3624 /* We check lpszTo[-1] to avoid skipping end of string. See the notes for
3625 * this function.
3626 */
3627 if (*lpszTo && lpszTo[-1])
3628 {
3629 if (*lpszTo != '\\')
3630 lpszTo--;
3631 dwLen = strlenW(lpszPath);
3633 {
3634 *lpszPath = '\0';
3636 }
3637 strcpyW(lpszPath + dwLen, lpszTo);
3638 }
3640}
WCHAR *WINAPI PathFindNextComponentW(const WCHAR *path)
Definition: path.c:2248
◆ PathRemoveArgsA()
Definition at line 756 of file path.c.
757{
759
760 if(lpszPath)
761 {
763 if (*lpszArgs)
764 lpszArgs[-1] = '\0';
765 else
766 {
768 if(*lpszLastChar == ' ')
769 *lpszLastChar = '\0';
770 }
771 }
772}
Referenced by ATL::CPathT< StringType >::PathRemoveArgsX().
◆ PathRemoveArgsW()
Definition at line 779 of file path.c.
780{
782
783 if(lpszPath)
784 {
786 if (*lpszArgs || (lpszArgs > lpszPath && lpszArgs[-1] == ' '))
787 lpszArgs[-1] = '\0';
788 }
789}
Referenced by RunOnceExEntry::Exec(), CAddressEditBox::ExecuteCommandLine(), CShellLink::OnNotify(), OpensWithExplorer(), ATL::CPathT< StringType >::PathRemoveArgsX(), SHELL_execute(), SHELL_translate_idlist(), ShellExecuteCommand(), and WelcomeDlgProc().
◆ PathRemoveBackslashA()
◆ PathRemoveBackslashW()
◆ PathRemoveBlanksA()
◆ PathRemoveBlanksW()
◆ PathRemoveExtensionA()
Definition at line 806 of file path.c.
807{
809
810 if (lpszPath)
811 {
812 lpszPath = PathFindExtensionA(lpszPath);
813 if (lpszPath && *lpszPath != '\0')
814 *lpszPath = '\0';
815 }
816}
◆ PathRemoveExtensionW()
Definition at line 823 of file path.c.
824{
826
827 if (lpszPath)
828 {
829 lpszPath = PathFindExtensionW(lpszPath);
830 if (lpszPath && *lpszPath != '\0')
831 *lpszPath = '\0';
832 }
833}
◆ PathRemoveFileSpecA()
Definition at line 586 of file path.c.
587{
588 LPSTR lpszFileSpec = lpszPath;
590
592
593 if(lpszPath)
594 {
595 /* Skip directory or UNC path */
596 if (*lpszPath == '\\')
597 lpszFileSpec = ++lpszPath;
598 if (*lpszPath == '\\')
599 lpszFileSpec = ++lpszPath;
600
601 while (*lpszPath)
602 {
603 if(*lpszPath == '\\')
604 lpszFileSpec = lpszPath; /* Skip dir */
605 else if(*lpszPath == ':')
606 {
607 lpszFileSpec = ++lpszPath; /* Skip drive */
608 if (*lpszPath == '\\')
609 lpszFileSpec++;
610 }
612 break;
613 }
614
615 if (*lpszFileSpec)
616 {
617 *lpszFileSpec = '\0';
618 bModified = TRUE;
619 }
620 }
621 return bModified;
622}
◆ PathRemoveFileSpecW()
Definition at line 629 of file path.c.
630{
631 LPWSTR lpszFileSpec = lpszPath;
633
635
636 if(lpszPath)
637 {
638 /* Skip directory or UNC path */
639 if (*lpszPath == '\\')
640 lpszFileSpec = ++lpszPath;
641 if (*lpszPath == '\\')
642 lpszFileSpec = ++lpszPath;
643
644 while (*lpszPath)
645 {
646 if(*lpszPath == '\\')
647 lpszFileSpec = lpszPath; /* Skip dir */
648 else if(*lpszPath == ':')
649 {
650 lpszFileSpec = ++lpszPath; /* Skip drive */
651 if (*lpszPath == '\\')
652 lpszFileSpec++;
653 }
654 lpszPath++;
655 }
656
657 if (*lpszFileSpec)
658 {
659 *lpszFileSpec = '\0';
660 bModified = TRUE;
661 }
662 }
663 return bModified;
664}
◆ PathRenameExtensionA()
Definition at line 3170 of file path.c.
3171{
3172 LPSTR lpszExtension;
3173
3175
3176 lpszExtension = PathFindExtensionA(lpszPath);
3177
3180
3181 strcpy(lpszExtension, lpszExt);
3183}
◆ PathRenameExtensionW()
Definition at line 3190 of file path.c.
3191{
3192 LPWSTR lpszExtension;
3193
3195
3196 lpszExtension = PathFindExtensionW(lpszPath);
3197
3200
3201 strcpyW(lpszExtension, lpszExt);
3203}
◆ PathSearchAndQualifyA()
Definition at line 3218 of file path.c.
3219{
3221
3225}
DWORD WINAPI SearchPathA(IN LPCSTR lpPath OPTIONAL, IN LPCSTR lpFileName, IN LPCSTR lpExtension OPTIONAL, IN DWORD nBufferLength, OUT LPSTR lpBuffer, OUT LPSTR *lpFilePart OPTIONAL)
Definition: path.c:1123
DWORD WINAPI GetFullPathNameA(IN LPCSTR lpFileName, IN DWORD nBufferLength, OUT LPSTR lpBuffer, OUT LPSTR *lpFilePart)
Definition: path.c:993
◆ PathSearchAndQualifyW()
Definition at line 3232 of file path.c.
3233{
3235
3239}
DWORD WINAPI SearchPathW(IN LPCWSTR lpPath OPTIONAL, IN LPCWSTR lpFileName, IN LPCWSTR lpExtension OPTIONAL, IN DWORD nBufferLength, OUT LPWSTR lpBuffer, OUT LPWSTR *lpFilePart OPTIONAL)
Definition: path.c:1298
DWORD WINAPI GetFullPathNameW(IN LPCWSTR lpFileName, IN DWORD nBufferLength, OUT LPWSTR lpBuffer, OUT LPWSTR *lpFilePart)
Definition: path.c:1106
◆ PathSetDlgItemPathA()
Definition at line 3707 of file path.c.
3708{
3710
3712
3713 if (lpszPath)
3715 else
3718}
VOID WINAPI PathSetDlgItemPathW(HWND hDlg, int id, LPCWSTR lpszPath)
Definition: path.c:3725
◆ PathSetDlgItemPathW()
Definition at line 3725 of file path.c.
3726{
3728 HWND hwItem;
3731 HGDIOBJ hPrevObj;
3732
3734
3736 return;
3737
3738 if (lpszPath)
3740 else
3742
3746
3747 if (hPrevObj)
3748 {
3751 }
3752
3755}
Definition: windef.h:99
HWND WINAPI GetDlgItem(_In_opt_ HWND, _In_ int)
BOOL WINAPI SetWindowTextW(_In_ HWND, _In_opt_ LPCWSTR)
BOOL WINAPI GetClientRect(_In_ HWND, _Out_ LPRECT)
LRESULT WINAPI SendMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
Referenced by PathSetDlgItemPathA().
◆ PathSkipRootA()
Definition at line 3253 of file path.c.
3254{
3256
3257 if (!lpszPath || !*lpszPath)
3259
3260 if (*lpszPath == '\\' && lpszPath[1] == '\\')
3261 {
3262 /* Network share: skip share server and mount point */
3263 lpszPath += 2;
3266 lpszPath++;
3268 }
3269
3272
3273 /* Check x:\ */
3274 if (lpszPath[0] && lpszPath[1] == ':' && lpszPath[2] == '\\')
3277}
◆ PathSkipRootW()
Definition at line 3284 of file path.c.
3285{
3287
3288 if (!lpszPath || !*lpszPath)
3290
3291 if (*lpszPath == '\\' && lpszPath[1] == '\\')
3292 {
3293 /* Network share: skip share server and mount point */
3294 lpszPath += 2;
3297 lpszPath++;
3299 }
3300
3301 /* Check x:\ */
3302 if (lpszPath[0] && lpszPath[1] == ':' && lpszPath[2] == '\\')
3305}
◆ PathStripPathA()
◆ PathStripPathW()
Definition at line 694 of file path.c.
695{
696 LPWSTR lpszFileName;
697
699 lpszFileName = PathFindFileNameW(lpszPath);
700 if(lpszFileName != lpszPath)
702}
◆ PathStripToRootA()
◆ PathStripToRootW()
◆ PathUndecorateA()
Definition at line 4070 of file path.c.
Referenced by test_PathUndecorate().
◆ PathUndecorateW()
Definition at line 4094 of file path.c.
4095{
4097
4099
4100 if (!pszPath) return;
4101
4104
4107 skip--;
4108
4111}
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
Referenced by test_PathUndecorate().
◆ PathUnExpandEnvStringsA()
Definition at line 4128 of file path.c.
4129{
4133
4135
4138
4142
4145
4148}
BOOL WINAPI PathUnExpandEnvStringsW(const WCHAR *path, WCHAR *buffer, UINT buf_len)
Definition: path.c:2705
◆ PathUnExpandEnvStringsW()
Definition at line 4181 of file path.c.
4182{
4192 { NULL }
4193 };
4194 DWORD pathlen;
4195 UINT needed;
4196
4198
4200 init_envvars_map(envvars);
4201 cur = envvars;
4203 {
4204 /* path can't contain expanded value or value wasn't retrieved */
4206 {
4207 cur++;
4208 continue;
4209 }
4210
4213 cur++;
4214 }
4215
4216 /* 'varlen' includes NULL termination char */
4219
4223
4225}
Definition: path.c:2688
Definition: match.c:28
◆ PathUnmakeSystemFolderA()
Definition at line 3655 of file path.c.
3656{
3657 DWORD dwAttr;
3658
3660
3661 if (!lpszPath || !*lpszPath || (dwAttr = GetFileAttributesA(lpszPath)) == INVALID_FILE_ATTRIBUTES ||
3662 !(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
3664
3667}
BOOL WINAPI SetFileAttributesA(LPCSTR lpFileName, DWORD dwFileAttributes)
Definition: fileinfo.c:776
◆ PathUnmakeSystemFolderW()
Definition at line 3674 of file path.c.
3675{
3676 DWORD dwAttr;
3677
3679
3680 if (!lpszPath || !*lpszPath || (dwAttr = GetFileAttributesW(lpszPath)) == INVALID_FILE_ATTRIBUTES ||
3681 !(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
3683
3686}
◆ PathUnquoteSpacesA()
◆ PathUnquoteSpacesW()
◆ SHGetWebFolderFilePathA()
Definition at line 4241 of file path.c.
4242{
4244 HRESULT hRet;
4245
4247
4252 return hRet;
4253}
HRESULT WINAPI SHGetWebFolderFilePathW(LPCWSTR, LPWSTR, DWORD)
Definition: path.c:4260
◆ SHGetWebFolderFilePathW()
Definition at line 4260 of file path.c.
4261{
4264#define szWebLen (sizeof(szWeb)/sizeof(WCHAR))
4265#define szWebMuiLen ((sizeof(szWebMui)+1)/sizeof(WCHAR))
4266 DWORD dwLen, dwFileLen;
4267 LANGID lidSystem, lidUser;
4268
4270
4271 /* Get base directory for web content */
4272 dwLen = GetSystemWindowsDirectoryW(lpszPath, dwPathLen);
4273 if (dwLen > 0 && lpszPath[dwLen-1] == '\\')
4274 dwLen--;
4275
4276 dwFileLen = strlenW(lpszFile);
4277
4280
4281 strcpyW(lpszPath+dwLen, szWeb);
4282 dwLen += szWebLen;
4283 dwPathLen = dwPathLen - dwLen; /* Remaining space */
4284
4285 lidSystem = GetSystemDefaultUILanguage();
4286 lidUser = GetUserDefaultUILanguage();
4287
4288 if (lidSystem != lidUser)
4289 {
4291 {
4292 /* Use localised content in the users UI language if present */
4293 wsprintfW(lpszPath + dwLen, szWebMui, lidUser);
4297 }
4298 }
4299
4300 /* Fall back to OS default installed content */
4301 strcpyW(lpszPath + dwLen, lpszFile);
4305}
UINT WINAPI GetSystemWindowsDirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2397
#define szWebMuiLen
#define szWebLen
int WINAPIV wsprintfW(_Out_ LPWSTR, _In_ _Printf_format_string_ LPCWSTR,...)
Referenced by SHGetWebFolderFilePathA().
◆ SHLWAPI_PathFindInOtherDirs()
Definition at line 1223 of file path.c.
1224{
1227 DWORD dwLenPATH;
1228 LPCWSTR lpszCurr;
1229 WCHAR *lpszPATH;
1231
1233
1234 /* Try system directories */
1239 {
1242 }
1247 {
1250 }
1255 {
1258 }
1259 /* Try dirs listed in %PATH% */
1261
1262 if (!dwLenPATH || !(lpszPATH = HeapAlloc(GetProcessHeap(), 0, (dwLenPATH + 1) * sizeof (WCHAR))))
1264
1266 lpszCurr = lpszPATH;
1267 while (lpszCurr)
1268 {
1269 LPCWSTR lpszEnd = lpszCurr;
1271
1272 while (*lpszEnd == ' ')
1273 lpszEnd++;
1274 while (*lpszEnd && *lpszEnd != ';')
1275 *pBuff++ = *lpszEnd++;
1276 *pBuff = '\0';
1277
1278 if (*lpszEnd)
1279 lpszCurr = lpszEnd + 1;
1280 else
1282
1284 {
1287 }
1289 {
1293 }
1294 }
1297}
Referenced by PathFindOnPathExA(), and PathFindOnPathExW().
◆ SHLWAPI_UseSystemForSystemFolders()
Definition at line 3076 of file path.c.
3077{
3080
3081 if (!bCheckedReg)
3082 {
3083 bCheckedReg = TRUE;
3084
3085 /* Key tells Win what file attributes to use on system folders */
3087 "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer",
3088 "UseSystemForSystemFolders", 0, 0, 0))
3089 bUseSystemForSystemFolders = TRUE;
3090 }
3091 return bUseSystemForSystemFolders;
3092}
Referenced by PathMakeSystemFolderW().
◆ WINE_DEFAULT_DEBUG_CHANNEL()
| WINE_DEFAULT_DEBUG_CHANNEL | ( | shell | ) |
Variable Documentation
◆ allusersprofileW
|
static |
Definition at line 4150 of file path.c.
Referenced by PathUnExpandEnvStringsW().
◆ appdataW
Definition at line 4151 of file path.c.
Referenced by PathUnExpandEnvStringsW().
◆ pIsNetDrive
|
static |
Definition at line 66 of file path.c.
Referenced by PathIsNetworkPathA(), and PathIsNetworkPathW().
◆ programfilesW
Definition at line 4152 of file path.c.
Referenced by PathUnExpandEnvStringsW(), and test_StdRegProv().
◆ SHELL_charclass
Definition at line 4323 of file path.c.
Referenced by PathIsValidCharA(), PathIsValidCharW(), test_PathIsValidCharA(), and test_PathIsValidCharW().
◆ SHLWAPI_hshell32
◆ systemdriveW
Definition at line 4154 of file path.c.
Referenced by PathUnExpandEnvStringsW(), and test_Win32_OperatingSystem().
◆ systemrootW
Definition at line 4153 of file path.c.
Referenced by create_file_test(), and PathUnExpandEnvStringsW().
