Mercurial > repo
comparison perl-5.22.2/win32/vdir.h @ 8045:a16537d2fe07
<xfix> tar xf perl-5.22.2.tar.gz # Ah, whatever, I\'m doing it anyway
author | HackBot |
---|---|
date | Sat, 14 May 2016 14:54:38 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
8044:711c038a7dce | 8045:a16537d2fe07 |
---|---|
1 /* vdir.h | |
2 * | |
3 * (c) 1999 Microsoft Corporation. All rights reserved. | |
4 * Portions (c) 1999 ActiveState Tool Corp, http://www.ActiveState.com/ | |
5 * | |
6 * You may distribute under the terms of either the GNU General Public | |
7 * License or the Artistic License, as specified in the README file. | |
8 */ | |
9 | |
10 #ifndef ___VDir_H___ | |
11 #define ___VDir_H___ | |
12 | |
13 /* | |
14 * Allow one slot for each possible drive letter | |
15 * and one additional slot for a UNC name | |
16 */ | |
17 const int driveCount = ('Z'-'A')+1+1; | |
18 const int driveLetterCount = ('Z'-'A')+1; | |
19 | |
20 class VDir | |
21 { | |
22 public: | |
23 VDir(int bManageDir = 1); | |
24 ~VDir() {}; | |
25 | |
26 void Init(VDir* pDir, VMem *pMem); | |
27 void SetDefaultA(char const *pDefault); | |
28 void SetDefaultW(WCHAR const *pDefault); | |
29 char* MapPathA(const char *pInName); | |
30 WCHAR* MapPathW(const WCHAR *pInName); | |
31 int SetCurrentDirectoryA(char *lpBuffer); | |
32 int SetCurrentDirectoryW(WCHAR *lpBuffer); | |
33 inline int GetDefault(void) { return nDefault; }; | |
34 | |
35 inline char* GetCurrentDirectoryA(int dwBufSize, char *lpBuffer) | |
36 { | |
37 char* ptr = dirTableA[nDefault]; | |
38 while (--dwBufSize) | |
39 { | |
40 if ((*lpBuffer++ = *ptr++) == '\0') | |
41 break; | |
42 } | |
43 *lpBuffer = '\0'; | |
44 return /* unused */ NULL; | |
45 }; | |
46 inline WCHAR* GetCurrentDirectoryW(int dwBufSize, WCHAR *lpBuffer) | |
47 { | |
48 WCHAR* ptr = dirTableW[nDefault]; | |
49 while (--dwBufSize) | |
50 { | |
51 if ((*lpBuffer++ = *ptr++) == '\0') | |
52 break; | |
53 } | |
54 *lpBuffer = '\0'; | |
55 return /* unused */ NULL; | |
56 }; | |
57 | |
58 DWORD CalculateEnvironmentSpace(void); | |
59 LPSTR BuildEnvironmentSpace(LPSTR lpStr); | |
60 | |
61 protected: | |
62 int SetDirA(char const *pPath, int index); | |
63 int SetDirW(WCHAR const *pPath, int index); | |
64 void FromEnvA(char *pEnv, int index); | |
65 void FromEnvW(WCHAR *pEnv, int index); | |
66 | |
67 inline const char *GetDefaultDirA(void) | |
68 { | |
69 return dirTableA[nDefault]; | |
70 }; | |
71 inline void SetDefaultDirA(char const *pPath, int index) | |
72 { | |
73 SetDirA(pPath, index); | |
74 nDefault = index; | |
75 }; | |
76 inline const WCHAR *GetDefaultDirW(void) | |
77 { | |
78 return dirTableW[nDefault]; | |
79 }; | |
80 inline void SetDefaultDirW(WCHAR const *pPath, int index) | |
81 { | |
82 SetDirW(pPath, index); | |
83 nDefault = index; | |
84 }; | |
85 inline const char *GetDirA(int index) | |
86 { | |
87 char *ptr = dirTableA[index]; | |
88 if (!ptr) { | |
89 /* simulate the existence of this drive */ | |
90 ptr = szLocalBufferA; | |
91 ptr[0] = 'A' + index; | |
92 ptr[1] = ':'; | |
93 ptr[2] = '\\'; | |
94 ptr[3] = 0; | |
95 } | |
96 return ptr; | |
97 }; | |
98 inline const WCHAR *GetDirW(int index) | |
99 { | |
100 WCHAR *ptr = dirTableW[index]; | |
101 if (!ptr) { | |
102 /* simulate the existence of this drive */ | |
103 ptr = szLocalBufferW; | |
104 ptr[0] = 'A' + index; | |
105 ptr[1] = ':'; | |
106 ptr[2] = '\\'; | |
107 ptr[3] = 0; | |
108 } | |
109 return ptr; | |
110 }; | |
111 | |
112 inline int DriveIndex(char chr) | |
113 { | |
114 if (chr == '\\' || chr == '/') | |
115 return ('Z'-'A')+1; | |
116 return (chr | 0x20)-'a'; | |
117 }; | |
118 | |
119 VMem *pMem; | |
120 int nDefault, bManageDirectory; | |
121 char *dirTableA[driveCount]; | |
122 char szLocalBufferA[MAX_PATH+1]; | |
123 WCHAR *dirTableW[driveCount]; | |
124 WCHAR szLocalBufferW[MAX_PATH+1]; | |
125 }; | |
126 | |
127 | |
128 VDir::VDir(int bManageDir /* = 1 */) | |
129 { | |
130 nDefault = 0; | |
131 bManageDirectory = bManageDir; | |
132 memset(dirTableA, 0, sizeof(dirTableA)); | |
133 memset(dirTableW, 0, sizeof(dirTableW)); | |
134 } | |
135 | |
136 void VDir::Init(VDir* pDir, VMem *p) | |
137 { | |
138 int index; | |
139 | |
140 pMem = p; | |
141 if (pDir) { | |
142 for (index = 0; index < driveCount; ++index) { | |
143 SetDirW(pDir->GetDirW(index), index); | |
144 } | |
145 nDefault = pDir->GetDefault(); | |
146 } | |
147 else { | |
148 int bSave = bManageDirectory; | |
149 DWORD driveBits = GetLogicalDrives(); | |
150 | |
151 bManageDirectory = 0; | |
152 WCHAR szBuffer[MAX_PATH*driveCount]; | |
153 if (GetLogicalDriveStringsW(sizeof(szBuffer), szBuffer)) { | |
154 WCHAR* pEnv = GetEnvironmentStringsW(); | |
155 WCHAR* ptr = szBuffer; | |
156 for (index = 0; index < driveCount; ++index) { | |
157 if (driveBits & (1<<index)) { | |
158 ptr += SetDirW(ptr, index) + 1; | |
159 FromEnvW(pEnv, index); | |
160 } | |
161 } | |
162 FreeEnvironmentStringsW(pEnv); | |
163 } | |
164 SetDefaultW(L"."); | |
165 bManageDirectory = bSave; | |
166 } | |
167 } | |
168 | |
169 int VDir::SetDirA(char const *pPath, int index) | |
170 { | |
171 char chr, *ptr; | |
172 int length = 0; | |
173 WCHAR wBuffer[MAX_PATH+1]; | |
174 if (index < driveCount && pPath != NULL) { | |
175 length = strlen(pPath); | |
176 pMem->Free(dirTableA[index]); | |
177 ptr = dirTableA[index] = (char*)pMem->Malloc(length+2); | |
178 if (ptr != NULL) { | |
179 strcpy(ptr, pPath); | |
180 ptr += length-1; | |
181 chr = *ptr++; | |
182 if (chr != '\\' && chr != '/') { | |
183 *ptr++ = '\\'; | |
184 *ptr = '\0'; | |
185 } | |
186 MultiByteToWideChar(CP_ACP, 0, dirTableA[index], -1, | |
187 wBuffer, (sizeof(wBuffer)/sizeof(WCHAR))); | |
188 length = wcslen(wBuffer); | |
189 pMem->Free(dirTableW[index]); | |
190 dirTableW[index] = (WCHAR*)pMem->Malloc((length+1)*2); | |
191 if (dirTableW[index] != NULL) { | |
192 wcscpy(dirTableW[index], wBuffer); | |
193 } | |
194 } | |
195 } | |
196 | |
197 if(bManageDirectory) | |
198 ::SetCurrentDirectoryA(pPath); | |
199 | |
200 return length; | |
201 } | |
202 | |
203 void VDir::FromEnvA(char *pEnv, int index) | |
204 { /* gets the directory for index from the environment variable. */ | |
205 while (*pEnv != '\0') { | |
206 if ((pEnv[0] == '=') && (DriveIndex(pEnv[1]) == index)) { | |
207 SetDirA(&pEnv[4], index); | |
208 break; | |
209 } | |
210 else | |
211 pEnv += strlen(pEnv)+1; | |
212 } | |
213 } | |
214 | |
215 void VDir::FromEnvW(WCHAR *pEnv, int index) | |
216 { /* gets the directory for index from the environment variable. */ | |
217 while (*pEnv != '\0') { | |
218 if ((pEnv[0] == '=') && (DriveIndex((char)pEnv[1]) == index)) { | |
219 SetDirW(&pEnv[4], index); | |
220 break; | |
221 } | |
222 else | |
223 pEnv += wcslen(pEnv)+1; | |
224 } | |
225 } | |
226 | |
227 void VDir::SetDefaultA(char const *pDefault) | |
228 { | |
229 char szBuffer[MAX_PATH+1]; | |
230 char *pPtr; | |
231 | |
232 if (GetFullPathNameA(pDefault, sizeof(szBuffer), szBuffer, &pPtr)) { | |
233 if (*pDefault != '.' && pPtr != NULL) | |
234 *pPtr = '\0'; | |
235 | |
236 SetDefaultDirA(szBuffer, DriveIndex(szBuffer[0])); | |
237 } | |
238 } | |
239 | |
240 int VDir::SetDirW(WCHAR const *pPath, int index) | |
241 { | |
242 WCHAR chr, *ptr; | |
243 int length = 0; | |
244 if (index < driveCount && pPath != NULL) { | |
245 length = wcslen(pPath); | |
246 pMem->Free(dirTableW[index]); | |
247 ptr = dirTableW[index] = (WCHAR*)pMem->Malloc((length+2)*2); | |
248 if (ptr != NULL) { | |
249 char *ansi; | |
250 wcscpy(ptr, pPath); | |
251 ptr += length-1; | |
252 chr = *ptr++; | |
253 if (chr != '\\' && chr != '/') { | |
254 *ptr++ = '\\'; | |
255 *ptr = '\0'; | |
256 } | |
257 ansi = win32_ansipath(dirTableW[index]); | |
258 length = strlen(ansi); | |
259 pMem->Free(dirTableA[index]); | |
260 dirTableA[index] = (char*)pMem->Malloc(length+1); | |
261 if (dirTableA[index] != NULL) { | |
262 strcpy(dirTableA[index], ansi); | |
263 } | |
264 win32_free(ansi); | |
265 } | |
266 } | |
267 | |
268 if(bManageDirectory) | |
269 ::SetCurrentDirectoryW(pPath); | |
270 | |
271 return length; | |
272 } | |
273 | |
274 void VDir::SetDefaultW(WCHAR const *pDefault) | |
275 { | |
276 WCHAR szBuffer[MAX_PATH+1]; | |
277 WCHAR *pPtr; | |
278 | |
279 if (GetFullPathNameW(pDefault, (sizeof(szBuffer)/sizeof(WCHAR)), szBuffer, &pPtr)) { | |
280 if (*pDefault != '.' && pPtr != NULL) | |
281 *pPtr = '\0'; | |
282 | |
283 SetDefaultDirW(szBuffer, DriveIndex((char)szBuffer[0])); | |
284 } | |
285 } | |
286 | |
287 inline BOOL IsPathSep(char ch) | |
288 { | |
289 return (ch == '\\' || ch == '/'); | |
290 } | |
291 | |
292 inline void DoGetFullPathNameA(char* lpBuffer, DWORD dwSize, char* Dest) | |
293 { | |
294 char *pPtr; | |
295 | |
296 /* | |
297 * On WinNT GetFullPathName does not fail, (or at least always | |
298 * succeeds when the drive is valid) WinNT does set *Dest to NULL | |
299 * On Win98 GetFullPathName will set last error if it fails, but | |
300 * does not touch *Dest | |
301 */ | |
302 *Dest = '\0'; | |
303 GetFullPathNameA(lpBuffer, dwSize, Dest, &pPtr); | |
304 } | |
305 | |
306 inline bool IsSpecialFileName(const char* pName) | |
307 { | |
308 /* specical file names are devices that the system can open | |
309 * these include AUX, CON, NUL, PRN, COMx, LPTx, CLOCK$, CONIN$, CONOUT$ | |
310 * (x is a single digit, and names are case-insensitive) | |
311 */ | |
312 char ch = (pName[0] & ~0x20); | |
313 switch (ch) | |
314 { | |
315 case 'A': /* AUX */ | |
316 if (((pName[1] & ~0x20) == 'U') | |
317 && ((pName[2] & ~0x20) == 'X') | |
318 && !pName[3]) | |
319 return true; | |
320 break; | |
321 case 'C': /* CLOCK$, COMx, CON, CONIN$ CONOUT$ */ | |
322 ch = (pName[1] & ~0x20); | |
323 switch (ch) | |
324 { | |
325 case 'L': /* CLOCK$ */ | |
326 if (((pName[2] & ~0x20) == 'O') | |
327 && ((pName[3] & ~0x20) == 'C') | |
328 && ((pName[4] & ~0x20) == 'K') | |
329 && (pName[5] == '$') | |
330 && !pName[6]) | |
331 return true; | |
332 break; | |
333 case 'O': /* COMx, CON, CONIN$ CONOUT$ */ | |
334 if ((pName[2] & ~0x20) == 'M') { | |
335 if ((pName[3] >= '1') && (pName[3] <= '9') | |
336 && !pName[4]) | |
337 return true; | |
338 } | |
339 else if ((pName[2] & ~0x20) == 'N') { | |
340 if (!pName[3]) | |
341 return true; | |
342 else if ((pName[3] & ~0x20) == 'I') { | |
343 if (((pName[4] & ~0x20) == 'N') | |
344 && (pName[5] == '$') | |
345 && !pName[6]) | |
346 return true; | |
347 } | |
348 else if ((pName[3] & ~0x20) == 'O') { | |
349 if (((pName[4] & ~0x20) == 'U') | |
350 && ((pName[5] & ~0x20) == 'T') | |
351 && (pName[6] == '$') | |
352 && !pName[7]) | |
353 return true; | |
354 } | |
355 } | |
356 break; | |
357 } | |
358 break; | |
359 case 'L': /* LPTx */ | |
360 if (((pName[1] & ~0x20) == 'U') | |
361 && ((pName[2] & ~0x20) == 'X') | |
362 && (pName[3] >= '1') && (pName[3] <= '9') | |
363 && !pName[4]) | |
364 return true; | |
365 break; | |
366 case 'N': /* NUL */ | |
367 if (((pName[1] & ~0x20) == 'U') | |
368 && ((pName[2] & ~0x20) == 'L') | |
369 && !pName[3]) | |
370 return true; | |
371 break; | |
372 case 'P': /* PRN */ | |
373 if (((pName[1] & ~0x20) == 'R') | |
374 && ((pName[2] & ~0x20) == 'N') | |
375 && !pName[3]) | |
376 return true; | |
377 break; | |
378 } | |
379 return false; | |
380 } | |
381 | |
382 char *VDir::MapPathA(const char *pInName) | |
383 { /* | |
384 * possiblities -- relative path or absolute path with or without drive letter | |
385 * OR UNC name | |
386 */ | |
387 int driveIndex; | |
388 char szBuffer[(MAX_PATH+1)*2]; | |
389 char szlBuf[MAX_PATH+1]; | |
390 int length = strlen(pInName); | |
391 | |
392 if (!length) | |
393 return (char*)pInName; | |
394 | |
395 if (length > MAX_PATH) { | |
396 strncpy(szlBuf, pInName, MAX_PATH); | |
397 if (IsPathSep(pInName[0]) && !IsPathSep(pInName[1])) { | |
398 /* absolute path - reduce length by 2 for drive specifier */ | |
399 szlBuf[MAX_PATH-2] = '\0'; | |
400 } | |
401 else | |
402 szlBuf[MAX_PATH] = '\0'; | |
403 pInName = szlBuf; | |
404 } | |
405 /* strlen(pInName) is now <= MAX_PATH */ | |
406 | |
407 if (length > 1 && pInName[1] == ':') { | |
408 /* has drive letter */ | |
409 if (length > 2 && IsPathSep(pInName[2])) { | |
410 /* absolute with drive letter */ | |
411 DoGetFullPathNameA((char*)pInName, sizeof(szLocalBufferA), szLocalBufferA); | |
412 } | |
413 else { | |
414 /* relative path with drive letter */ | |
415 driveIndex = DriveIndex(*pInName); | |
416 if (driveIndex < 0 || driveIndex >= driveLetterCount) | |
417 return (char *)pInName; | |
418 strcpy(szBuffer, GetDirA(driveIndex)); | |
419 strcat(szBuffer, &pInName[2]); | |
420 if(strlen(szBuffer) > MAX_PATH) | |
421 szBuffer[MAX_PATH] = '\0'; | |
422 | |
423 DoGetFullPathNameA(szBuffer, sizeof(szLocalBufferA), szLocalBufferA); | |
424 } | |
425 } | |
426 else { | |
427 /* no drive letter */ | |
428 if (length > 1 && IsPathSep(pInName[1]) && IsPathSep(pInName[0])) { | |
429 /* UNC name */ | |
430 DoGetFullPathNameA((char*)pInName, sizeof(szLocalBufferA), szLocalBufferA); | |
431 } | |
432 else { | |
433 strcpy(szBuffer, GetDefaultDirA()); | |
434 if (IsPathSep(pInName[0])) { | |
435 /* absolute path */ | |
436 strcpy(&szBuffer[2], pInName); | |
437 DoGetFullPathNameA(szBuffer, sizeof(szLocalBufferA), szLocalBufferA); | |
438 } | |
439 else { | |
440 /* relative path */ | |
441 if (IsSpecialFileName(pInName)) { | |
442 return (char*)pInName; | |
443 } | |
444 else { | |
445 strcat(szBuffer, pInName); | |
446 if (strlen(szBuffer) > MAX_PATH) | |
447 szBuffer[MAX_PATH] = '\0'; | |
448 | |
449 DoGetFullPathNameA(szBuffer, sizeof(szLocalBufferA), szLocalBufferA); | |
450 } | |
451 } | |
452 } | |
453 } | |
454 | |
455 return szLocalBufferA; | |
456 } | |
457 | |
458 int VDir::SetCurrentDirectoryA(char *lpBuffer) | |
459 { | |
460 char *pPtr; | |
461 int length, nRet = -1; | |
462 | |
463 pPtr = MapPathA(lpBuffer); | |
464 length = strlen(pPtr); | |
465 if(length > 3 && IsPathSep(pPtr[length-1])) { | |
466 /* don't remove the trailing slash from 'x:\' */ | |
467 pPtr[length-1] = '\0'; | |
468 } | |
469 | |
470 DWORD r = GetFileAttributesA(pPtr); | |
471 if ((r != 0xffffffff) && (r & FILE_ATTRIBUTE_DIRECTORY)) | |
472 { | |
473 char szBuffer[(MAX_PATH+1)*2]; | |
474 DoGetFullPathNameA(pPtr, sizeof(szBuffer), szBuffer); | |
475 SetDefaultDirA(szBuffer, DriveIndex(szBuffer[0])); | |
476 nRet = 0; | |
477 } | |
478 | |
479 return nRet; | |
480 } | |
481 | |
482 DWORD VDir::CalculateEnvironmentSpace(void) | |
483 { /* the current directory environment strings are stored as '=D:=d:\path' */ | |
484 int index; | |
485 DWORD dwSize = 0; | |
486 for (index = 0; index < driveCount; ++index) { | |
487 if (dirTableA[index] != NULL) { | |
488 dwSize += strlen(dirTableA[index]) + 5; /* add 1 for trailing NULL and 4 for '=D:=' */ | |
489 } | |
490 } | |
491 return dwSize; | |
492 } | |
493 | |
494 LPSTR VDir::BuildEnvironmentSpace(LPSTR lpStr) | |
495 { /* store the current directory environment strings as '=D:=d:\path' */ | |
496 int index, length; | |
497 LPSTR lpDirStr; | |
498 for (index = 0; index < driveCount; ++index) { | |
499 lpDirStr = dirTableA[index]; | |
500 if (lpDirStr != NULL) { | |
501 lpStr[0] = '='; | |
502 lpStr[1] = lpDirStr[0]; | |
503 lpStr[2] = '\0'; | |
504 CharUpper(&lpStr[1]); | |
505 lpStr[2] = ':'; | |
506 lpStr[3] = '='; | |
507 strcpy(&lpStr[4], lpDirStr); | |
508 length = strlen(lpDirStr); | |
509 lpStr += length + 5; /* add 1 for trailing NULL and 4 for '=D:=' */ | |
510 if (length > 3 && IsPathSep(lpStr[-2])) { | |
511 lpStr[-2] = '\0'; /* remove the trailing path separator */ | |
512 --lpStr; | |
513 } | |
514 } | |
515 } | |
516 return lpStr; | |
517 } | |
518 | |
519 inline BOOL IsPathSep(WCHAR ch) | |
520 { | |
521 return (ch == '\\' || ch == '/'); | |
522 } | |
523 | |
524 inline void DoGetFullPathNameW(WCHAR* lpBuffer, DWORD dwSize, WCHAR* Dest) | |
525 { | |
526 WCHAR *pPtr; | |
527 | |
528 /* | |
529 * On WinNT GetFullPathName does not fail, (or at least always | |
530 * succeeds when the drive is valid) WinNT does set *Dest to NULL | |
531 * On Win98 GetFullPathName will set last error if it fails, but | |
532 * does not touch *Dest | |
533 */ | |
534 *Dest = '\0'; | |
535 GetFullPathNameW(lpBuffer, dwSize, Dest, &pPtr); | |
536 } | |
537 | |
538 inline bool IsSpecialFileName(const WCHAR* pName) | |
539 { | |
540 /* specical file names are devices that the system can open | |
541 * these include AUX, CON, NUL, PRN, COMx, LPTx, CLOCK$, CONIN$, CONOUT$ | |
542 * (x is a single digit, and names are case-insensitive) | |
543 */ | |
544 WCHAR ch = (pName[0] & ~0x20); | |
545 switch (ch) | |
546 { | |
547 case 'A': /* AUX */ | |
548 if (((pName[1] & ~0x20) == 'U') | |
549 && ((pName[2] & ~0x20) == 'X') | |
550 && !pName[3]) | |
551 return true; | |
552 break; | |
553 case 'C': /* CLOCK$, COMx, CON, CONIN$ CONOUT$ */ | |
554 ch = (pName[1] & ~0x20); | |
555 switch (ch) | |
556 { | |
557 case 'L': /* CLOCK$ */ | |
558 if (((pName[2] & ~0x20) == 'O') | |
559 && ((pName[3] & ~0x20) == 'C') | |
560 && ((pName[4] & ~0x20) == 'K') | |
561 && (pName[5] == '$') | |
562 && !pName[6]) | |
563 return true; | |
564 break; | |
565 case 'O': /* COMx, CON, CONIN$ CONOUT$ */ | |
566 if ((pName[2] & ~0x20) == 'M') { | |
567 if ((pName[3] >= '1') && (pName[3] <= '9') | |
568 && !pName[4]) | |
569 return true; | |
570 } | |
571 else if ((pName[2] & ~0x20) == 'N') { | |
572 if (!pName[3]) | |
573 return true; | |
574 else if ((pName[3] & ~0x20) == 'I') { | |
575 if (((pName[4] & ~0x20) == 'N') | |
576 && (pName[5] == '$') | |
577 && !pName[6]) | |
578 return true; | |
579 } | |
580 else if ((pName[3] & ~0x20) == 'O') { | |
581 if (((pName[4] & ~0x20) == 'U') | |
582 && ((pName[5] & ~0x20) == 'T') | |
583 && (pName[6] == '$') | |
584 && !pName[7]) | |
585 return true; | |
586 } | |
587 } | |
588 break; | |
589 } | |
590 break; | |
591 case 'L': /* LPTx */ | |
592 if (((pName[1] & ~0x20) == 'U') | |
593 && ((pName[2] & ~0x20) == 'X') | |
594 && (pName[3] >= '1') && (pName[3] <= '9') | |
595 && !pName[4]) | |
596 return true; | |
597 break; | |
598 case 'N': /* NUL */ | |
599 if (((pName[1] & ~0x20) == 'U') | |
600 && ((pName[2] & ~0x20) == 'L') | |
601 && !pName[3]) | |
602 return true; | |
603 break; | |
604 case 'P': /* PRN */ | |
605 if (((pName[1] & ~0x20) == 'R') | |
606 && ((pName[2] & ~0x20) == 'N') | |
607 && !pName[3]) | |
608 return true; | |
609 break; | |
610 } | |
611 return false; | |
612 } | |
613 | |
614 WCHAR* VDir::MapPathW(const WCHAR *pInName) | |
615 { /* | |
616 * possiblities -- relative path or absolute path with or without drive letter | |
617 * OR UNC name | |
618 */ | |
619 int driveIndex; | |
620 WCHAR szBuffer[(MAX_PATH+1)*2]; | |
621 WCHAR szlBuf[MAX_PATH+1]; | |
622 int length = wcslen(pInName); | |
623 | |
624 if (!length) | |
625 return (WCHAR*)pInName; | |
626 | |
627 if (length > MAX_PATH) { | |
628 wcsncpy(szlBuf, pInName, MAX_PATH); | |
629 if (IsPathSep(pInName[0]) && !IsPathSep(pInName[1])) { | |
630 /* absolute path - reduce length by 2 for drive specifier */ | |
631 szlBuf[MAX_PATH-2] = '\0'; | |
632 } | |
633 else | |
634 szlBuf[MAX_PATH] = '\0'; | |
635 pInName = szlBuf; | |
636 } | |
637 /* strlen(pInName) is now <= MAX_PATH */ | |
638 | |
639 if (length > 1 && pInName[1] == ':') { | |
640 /* has drive letter */ | |
641 if (IsPathSep(pInName[2])) { | |
642 /* absolute with drive letter */ | |
643 DoGetFullPathNameW((WCHAR*)pInName, (sizeof(szLocalBufferW)/sizeof(WCHAR)), szLocalBufferW); | |
644 } | |
645 else { | |
646 /* relative path with drive letter */ | |
647 driveIndex = DriveIndex(*pInName); | |
648 if (driveIndex < 0 || driveIndex >= driveLetterCount) | |
649 return (WCHAR *)pInName; | |
650 wcscpy(szBuffer, GetDirW(driveIndex)); | |
651 wcscat(szBuffer, &pInName[2]); | |
652 if(wcslen(szBuffer) > MAX_PATH) | |
653 szBuffer[MAX_PATH] = '\0'; | |
654 | |
655 DoGetFullPathNameW(szBuffer, (sizeof(szLocalBufferW)/sizeof(WCHAR)), szLocalBufferW); | |
656 } | |
657 } | |
658 else { | |
659 /* no drive letter */ | |
660 if (length > 1 && IsPathSep(pInName[1]) && IsPathSep(pInName[0])) { | |
661 /* UNC name */ | |
662 DoGetFullPathNameW((WCHAR*)pInName, (sizeof(szLocalBufferW)/sizeof(WCHAR)), szLocalBufferW); | |
663 } | |
664 else { | |
665 wcscpy(szBuffer, GetDefaultDirW()); | |
666 if (IsPathSep(pInName[0])) { | |
667 /* absolute path */ | |
668 wcscpy(&szBuffer[2], pInName); | |
669 DoGetFullPathNameW(szBuffer, (sizeof(szLocalBufferW)/sizeof(WCHAR)), szLocalBufferW); | |
670 } | |
671 else { | |
672 /* relative path */ | |
673 if (IsSpecialFileName(pInName)) { | |
674 return (WCHAR*)pInName; | |
675 } | |
676 else { | |
677 wcscat(szBuffer, pInName); | |
678 if (wcslen(szBuffer) > MAX_PATH) | |
679 szBuffer[MAX_PATH] = '\0'; | |
680 | |
681 DoGetFullPathNameW(szBuffer, (sizeof(szLocalBufferW)/sizeof(WCHAR)), szLocalBufferW); | |
682 } | |
683 } | |
684 } | |
685 } | |
686 return szLocalBufferW; | |
687 } | |
688 | |
689 int VDir::SetCurrentDirectoryW(WCHAR *lpBuffer) | |
690 { | |
691 WCHAR *pPtr; | |
692 int length, nRet = -1; | |
693 | |
694 pPtr = MapPathW(lpBuffer); | |
695 length = wcslen(pPtr); | |
696 if(length > 3 && IsPathSep(pPtr[length-1])) { | |
697 /* don't remove the trailing slash from 'x:\' */ | |
698 pPtr[length-1] = '\0'; | |
699 } | |
700 | |
701 DWORD r = GetFileAttributesW(pPtr); | |
702 if ((r != 0xffffffff) && (r & FILE_ATTRIBUTE_DIRECTORY)) | |
703 { | |
704 WCHAR wBuffer[(MAX_PATH+1)*2]; | |
705 DoGetFullPathNameW(pPtr, (sizeof(wBuffer)/sizeof(WCHAR)), wBuffer); | |
706 SetDefaultDirW(wBuffer, DriveIndex((char)wBuffer[0])); | |
707 nRet = 0; | |
708 } | |
709 | |
710 return nRet; | |
711 } | |
712 | |
713 #endif /* ___VDir_H___ */ |