[p5sagit/p5-mst-13.2.git] / win32 / vdir.h

/* vdir.h
 *
 * (c) 1999 Microsoft Corporation. All rights reserved. 
 * Portions (c) 1999 ActiveState Tool Corp, http://www.ActiveState.com/
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 */

#ifndef ___VDir_H___
#define ___VDir_H___

/*
 * Allow one slot for each possible drive letter
 * and one additional slot for a UNC name
 */
const int driveCount = ('Z'-'A')+1+1;

class VDir
{
public:
    VDir(int bManageDir = 1);
    ~VDir() {};

    void Init(VDir* pDir, VMem *pMem);
    void SetDefaultA(char const *pDefault);
    void SetDefaultW(WCHAR const *pDefault);
    char* MapPathA(const char *pInName);
    WCHAR* MapPathW(const WCHAR *pInName);
    int SetCurrentDirectoryA(char *lpBuffer);
    int SetCurrentDirectoryW(WCHAR *lpBuffer);
    inline int GetDefault(void) { return nDefault; };

    inline char* GetCurrentDirectoryA(int dwBufSize, char *lpBuffer)
    {
	char* ptr = dirTableA[nDefault];
	while (--dwBufSize)
	{
	    if ((*lpBuffer++ = *ptr++) == '\0')
		break;
	}
        *lpBuffer = '\0';
	return /* unused */ NULL;
    };
    inline WCHAR* GetCurrentDirectoryW(int dwBufSize, WCHAR *lpBuffer)
    {
	WCHAR* ptr = dirTableW[nDefault];
	while (--dwBufSize)
	{
	    if ((*lpBuffer++ = *ptr++) == '\0')
		break;
	}
        *lpBuffer = '\0';
	return /* unused */ NULL;
    };

    DWORD CalculateEnvironmentSpace(void);
    LPSTR BuildEnvironmentSpace(LPSTR lpStr);

protected:
    int SetDirA(char const *pPath, int index);
    int SetDirW(WCHAR const *pPath, int index);
    void FromEnvA(char *pEnv, int index);
    void FromEnvW(WCHAR *pEnv, int index);

    inline const char *GetDefaultDirA(void)
    {
	return dirTableA[nDefault];
    };
    inline void SetDefaultDirA(char const *pPath, int index)
    {
	SetDirA(pPath, index);
	nDefault = index;
    };
    inline const WCHAR *GetDefaultDirW(void)
    {
	return dirTableW[nDefault];
    };
    inline void SetDefaultDirW(WCHAR const *pPath, int index)
    {
	SetDirW(pPath, index);
	nDefault = index;
    };
    inline const char *GetDirA(int index)
    {
	char *ptr = dirTableA[index];
	if (!ptr) {
	    /* simulate the existance of this drive */
	    ptr = szLocalBufferA;
	    ptr[0] = 'A' + index;
	    ptr[1] = ':';
	    ptr[2] = '\\';
	    ptr[3] = 0;
	}
	return ptr;
    };
    inline const WCHAR *GetDirW(int index)
    {
	WCHAR *ptr = dirTableW[index];
	if (!ptr) {
	    /* simulate the existance of this drive */
	    ptr = szLocalBufferW;
	    ptr[0] = 'A' + index;
	    ptr[1] = ':';
	    ptr[2] = '\\';
	    ptr[3] = 0;
	}
	return ptr;
    };

    inline int DriveIndex(char chr)
    {
	if (chr == '\\' || chr == '/')
	    return ('Z'-'A')+1;
	return (chr | 0x20)-'a';
    };

    VMem *pMem;
    int nDefault, bManageDirectory;
    char *dirTableA[driveCount];
    char szLocalBufferA[MAX_PATH+1];
    WCHAR *dirTableW[driveCount];
    WCHAR szLocalBufferW[MAX_PATH+1];
};


VDir::VDir(int bManageDir /* = 1 */)
{
    nDefault = 0;
    bManageDirectory = bManageDir;
    memset(dirTableA, 0, sizeof(dirTableA));
    memset(dirTableW, 0, sizeof(dirTableW));
}

void VDir::Init(VDir* pDir, VMem *p)
{
    int index;

    pMem = p;
    if (pDir) {
	for (index = 0; index < driveCount; ++index) {
	    SetDirW(pDir->GetDirW(index), index);
	}
	nDefault = pDir->GetDefault();
    }
    else {
	int bSave = bManageDirectory;
	DWORD driveBits = GetLogicalDrives();
        OSVERSIONINFO osver;

        memset(&osver, 0, sizeof(osver));
        osver.dwOSVersionInfoSize = sizeof(osver);
        GetVersionEx(&osver);

	bManageDirectory = 0;
        if (osver.dwMajorVersion < 5) {
            char szBuffer[MAX_PATH*driveCount];
            if (GetLogicalDriveStringsA(sizeof(szBuffer), szBuffer)) {
                char* pEnv = (char*)GetEnvironmentStringsA();
                char* ptr = szBuffer;
                for (index = 0; index < driveCount; ++index) {
                    if (driveBits & (1<<index)) {
                        ptr += SetDirA(ptr, index) + 1;
                        FromEnvA(pEnv, index);
                    }
                }
                FreeEnvironmentStringsA(pEnv);
            }
            SetDefaultA(".");
        }
        else { /* Windows 2000 or later */
            WCHAR szBuffer[MAX_PATH*driveCount];
            if (GetLogicalDriveStringsW(sizeof(szBuffer), szBuffer)) {
                WCHAR* pEnv = GetEnvironmentStringsW();
                WCHAR* ptr = szBuffer;
                for (index = 0; index < driveCount; ++index) {
                    if (driveBits & (1<<index)) {
                        ptr += SetDirW(ptr, index) + 1;
                        FromEnvW(pEnv, index);
                    }
                }
                FreeEnvironmentStringsW(pEnv);
            }
            SetDefaultW(L".");
        }
	bManageDirectory = bSave;
  }
}

int VDir::SetDirA(char const *pPath, int index)
{
    char chr, *ptr;
    int length = 0;
    WCHAR wBuffer[MAX_PATH+1];
    if (index < driveCount && pPath != NULL) {
	length = strlen(pPath);
	pMem->Free(dirTableA[index]);
	ptr = dirTableA[index] = (char*)pMem->Malloc(length+2);
	if (ptr != NULL) {
	    strcpy(ptr, pPath);
	    ptr += length-1;
	    chr = *ptr++;
	    if (chr != '\\' && chr != '/') {
		*ptr++ = '\\';
		*ptr = '\0';
	    }
	    MultiByteToWideChar(CP_ACP, 0, dirTableA[index], -1,
		    wBuffer, (sizeof(wBuffer)/sizeof(WCHAR)));
	    length = wcslen(wBuffer);
	    pMem->Free(dirTableW[index]);
	    dirTableW[index] = (WCHAR*)pMem->Malloc((length+1)*2);
	    if (dirTableW[index] != NULL) {
		wcscpy(dirTableW[index], wBuffer);
	    }
	}
    }

    if(bManageDirectory)
	::SetCurrentDirectoryA(pPath);

    return length;
}

void VDir::FromEnvA(char *pEnv, int index)
{   /* gets the directory for index from the environment variable. */
    while (*pEnv != '\0') {
	if ((pEnv[0] == '=') && (DriveIndex(pEnv[1]) == index)) {
	    SetDirA(&pEnv[4], index);
	    break;
	}
	else
	    pEnv += strlen(pEnv)+1;
    }
}

void VDir::FromEnvW(WCHAR *pEnv, int index)
{   /* gets the directory for index from the environment variable. */
    while (*pEnv != '\0') {
	if ((pEnv[0] == '=') && (DriveIndex((char)pEnv[1]) == index)) {
	    SetDirW(&pEnv[4], index);
	    break;
	}
	else
	    pEnv += wcslen(pEnv)+1;
    }
}

void VDir::SetDefaultA(char const *pDefault)
{
    char szBuffer[MAX_PATH+1];
    char *pPtr;

    if (GetFullPathNameA(pDefault, sizeof(szBuffer), szBuffer, &pPtr)) {
        if (*pDefault != '.' && pPtr != NULL)
	    *pPtr = '\0';

	SetDefaultDirA(szBuffer, DriveIndex(szBuffer[0]));
    }
}

int VDir::SetDirW(WCHAR const *pPath, int index)
{
    WCHAR chr, *ptr;
    int length = 0;
    if (index < driveCount && pPath != NULL) {
	length = wcslen(pPath);
	pMem->Free(dirTableW[index]);
	ptr = dirTableW[index] = (WCHAR*)pMem->Malloc((length+2)*2);
	if (ptr != NULL) {
            char *ansi;
	    wcscpy(ptr, pPath);
	    ptr += length-1;
	    chr = *ptr++;
	    if (chr != '\\' && chr != '/') {
		*ptr++ = '\\';
		*ptr = '\0';
	    }
            ansi = win32_ansipath(dirTableW[index]);
	    length = strlen(ansi);
	    pMem->Free(dirTableA[index]);
	    dirTableA[index] = (char*)pMem->Malloc(length+1);
	    if (dirTableA[index] != NULL) {
		strcpy(dirTableA[index], ansi);
	    }
            win32_free(ansi);
	}
    }

    if(bManageDirectory)
	::SetCurrentDirectoryW(pPath);

    return length;
}

void VDir::SetDefaultW(WCHAR const *pDefault)
{
    WCHAR szBuffer[MAX_PATH+1];
    WCHAR *pPtr;

    if (GetFullPathNameW(pDefault, (sizeof(szBuffer)/sizeof(WCHAR)), szBuffer, &pPtr)) {
        if (*pDefault != '.' && pPtr != NULL)
	    *pPtr = '\0';

	SetDefaultDirW(szBuffer, DriveIndex((char)szBuffer[0]));
    }
}

inline BOOL IsPathSep(char ch)
{
    return (ch == '\\' || ch == '/');
}

inline void DoGetFullPathNameA(char* lpBuffer, DWORD dwSize, char* Dest)
{
    char *pPtr;

    /*
     * On WinNT GetFullPathName does not fail, (or at least always
     * succeeds when the drive is valid) WinNT does set *Dest to Nullch
     * On Win98 GetFullPathName will set last error if it fails, but
     * does not touch *Dest
     */
    *Dest = '\0';
    GetFullPathNameA(lpBuffer, dwSize, Dest, &pPtr);
}

inline bool IsSpecialFileName(const char* pName)
{
    /* specical file names are devices that the system can open
     * these include AUX, CON, NUL, PRN, COMx, LPTx, CLOCK$, CONIN$, CONOUT$
     * (x is a single digit, and names are case-insensitive)
     */
    char ch = (pName[0] & ~0x20);
    switch (ch)
    {
	case 'A': /* AUX */
	    if (((pName[1] & ~0x20) == 'U')
		&& ((pName[2] & ~0x20) == 'X')
		&& !pName[3])
		    return true;
	    break;
	case 'C': /* CLOCK$, COMx,  CON, CONIN$ CONOUT$ */
	    ch = (pName[1] & ~0x20);
	    switch (ch)
	    {
		case 'L': /* CLOCK$ */
		    if (((pName[2] & ~0x20) == 'O')
			&& ((pName[3] & ~0x20) == 'C')
			&& ((pName[4] & ~0x20) == 'K')
			&& (pName[5] == '$')
			&& !pName[6])
			    return true;
		    break;
		case 'O': /* COMx,  CON, CONIN$ CONOUT$ */
		    if ((pName[2] & ~0x20) == 'M') {
			if ((pName[3] >= '1') && (pName[3] <= '9')
			    && !pName[4])
			    return true;
		    }
		    else if ((pName[2] & ~0x20) == 'N') {
			if (!pName[3])
			    return true;
			else if ((pName[3] & ~0x20) == 'I') {
			    if (((pName[4] & ~0x20) == 'N')
				&& (pName[5] == '$')
				&& !pName[6])
			    return true;
			}
			else if ((pName[3] & ~0x20) == 'O') {
			    if (((pName[4] & ~0x20) == 'U')
				&& ((pName[5] & ~0x20) == 'T')
				&& (pName[6] == '$')
				&& !pName[7])
			    return true;
			}
		    }
		    break;
	    }
	    break;
	case 'L': /* LPTx */
	    if (((pName[1] & ~0x20) == 'U')
		&& ((pName[2] & ~0x20) == 'X')
		&& (pName[3] >= '1') && (pName[3] <= '9')
		&& !pName[4])
		    return true;
	    break;
	case 'N': /* NUL */
	    if (((pName[1] & ~0x20) == 'U')
		&& ((pName[2] & ~0x20) == 'L')
		&& !pName[3])
		    return true;
	    break;
	case 'P': /* PRN */
	    if (((pName[1] & ~0x20) == 'R')
		&& ((pName[2] & ~0x20) == 'N')
		&& !pName[3])
		    return true;
	    break;
    }
    return false;
}

char *VDir::MapPathA(const char *pInName)
{   /*
     * possiblities -- relative path or absolute path with or without drive letter
     * OR UNC name
     */
    char szBuffer[(MAX_PATH+1)*2];
    char szlBuf[MAX_PATH+1];
    int length = strlen(pInName);

    if (!length)
	return (char*)pInName;

    if (length > MAX_PATH) {
	strncpy(szlBuf, pInName, MAX_PATH);
	if (IsPathSep(pInName[0]) && !IsPathSep(pInName[1])) {   
	    /* absolute path - reduce length by 2 for drive specifier */
	    szlBuf[MAX_PATH-2] = '\0';
	}
	else
	    szlBuf[MAX_PATH] = '\0';
	pInName = szlBuf;
    }
    /* strlen(pInName) is now <= MAX_PATH */

    if (pInName[1] == ':') {
	/* has drive letter */
	if (IsPathSep(pInName[2])) {
	    /* absolute with drive letter */
	    DoGetFullPathNameA((char*)pInName, sizeof(szLocalBufferA), szLocalBufferA);
	}
	else {
	    /* relative path with drive letter */
	    strcpy(szBuffer, GetDirA(DriveIndex(*pInName)));
	    strcat(szBuffer, &pInName[2]);
	    if(strlen(szBuffer) > MAX_PATH)
		szBuffer[MAX_PATH] = '\0';

	    DoGetFullPathNameA(szBuffer, sizeof(szLocalBufferA), szLocalBufferA);
	}
    }
    else {
	/* no drive letter */
	if (IsPathSep(pInName[1]) && IsPathSep(pInName[0])) {
	    /* UNC name */
	    DoGetFullPathNameA((char*)pInName, sizeof(szLocalBufferA), szLocalBufferA);
	}
	else {
	    strcpy(szBuffer, GetDefaultDirA());
	    if (IsPathSep(pInName[0])) {
		/* absolute path */
		strcpy(&szBuffer[2], pInName);
		DoGetFullPathNameA(szBuffer, sizeof(szLocalBufferA), szLocalBufferA);
	    }
	    else {
		/* relative path */
		if (IsSpecialFileName(pInName)) {
		    return (char*)pInName;
		}
		else {
		    strcat(szBuffer, pInName);
		    if (strlen(szBuffer) > MAX_PATH)
			szBuffer[MAX_PATH] = '\0';

		    DoGetFullPathNameA(szBuffer, sizeof(szLocalBufferA), szLocalBufferA);
		}
	    }
	}
    }

    return szLocalBufferA;
}

int VDir::SetCurrentDirectoryA(char *lpBuffer)
{
    char *pPtr;
    int length, nRet = -1;

    pPtr = MapPathA(lpBuffer);
    length = strlen(pPtr);
    if(length > 3 && IsPathSep(pPtr[length-1])) {
	/* don't remove the trailing slash from 'x:\'  */
	pPtr[length-1] = '\0';
    }

    DWORD r = GetFileAttributesA(pPtr);
    if ((r != 0xffffffff) && (r & FILE_ATTRIBUTE_DIRECTORY))
    {
	char szBuffer[(MAX_PATH+1)*2];
	DoGetFullPathNameA(pPtr, sizeof(szBuffer), szBuffer);
	SetDefaultDirA(szBuffer, DriveIndex(szBuffer[0]));
	nRet = 0;
    }

    return nRet;
}

DWORD VDir::CalculateEnvironmentSpace(void)
{   /* the current directory environment strings are stored as '=D:=d:\path' */
    int index;
    DWORD dwSize = 0;
    for (index = 0; index < driveCount; ++index) {
	if (dirTableA[index] != NULL) {
	    dwSize += strlen(dirTableA[index]) + 5;  /* add 1 for trailing NULL and 4 for '=D:=' */
	}
    }
    return dwSize;
}

LPSTR VDir::BuildEnvironmentSpace(LPSTR lpStr)
{   /* store the current directory environment strings as '=D:=d:\path' */
    int index, length;
    LPSTR lpDirStr;
    for (index = 0; index < driveCount; ++index) {
	lpDirStr = dirTableA[index];
	if (lpDirStr != NULL) {
	    lpStr[0] = '=';
	    lpStr[1] = lpDirStr[0];
	    lpStr[2] = '\0';
	    CharUpper(&lpStr[1]);
	    lpStr[2] = ':';
	    lpStr[3] = '=';
	    strcpy(&lpStr[4], lpDirStr);
	    length = strlen(lpDirStr);
	    lpStr += length + 5; /* add 1 for trailing NULL and 4 for '=D:=' */
	    if (length > 3 && IsPathSep(lpStr[-2])) {
		lpStr[-2] = '\0';   /* remove the trailing path separator */
		--lpStr;
	    }
	}
    }
    return lpStr;
}

inline BOOL IsPathSep(WCHAR ch)
{
    return (ch == '\\' || ch == '/');
}

inline void DoGetFullPathNameW(WCHAR* lpBuffer, DWORD dwSize, WCHAR* Dest)
{
    WCHAR *pPtr;

    /*
     * On WinNT GetFullPathName does not fail, (or at least always
     * succeeds when the drive is valid) WinNT does set *Dest to Nullch
     * On Win98 GetFullPathName will set last error if it fails, but
     * does not touch *Dest
     */
    *Dest = '\0';
    GetFullPathNameW(lpBuffer, dwSize, Dest, &pPtr);
}

inline bool IsSpecialFileName(const WCHAR* pName)
{
    /* specical file names are devices that the system can open
     * these include AUX, CON, NUL, PRN, COMx, LPTx, CLOCK$, CONIN$, CONOUT$
     * (x is a single digit, and names are case-insensitive)
     */
    WCHAR ch = (pName[0] & ~0x20);
    switch (ch)
    {
	case 'A': /* AUX */
	    if (((pName[1] & ~0x20) == 'U')
		&& ((pName[2] & ~0x20) == 'X')
		&& !pName[3])
		    return true;
	    break;
	case 'C': /* CLOCK$, COMx,  CON, CONIN$ CONOUT$ */
	    ch = (pName[1] & ~0x20);
	    switch (ch)
	    {
		case 'L': /* CLOCK$ */
		    if (((pName[2] & ~0x20) == 'O')
			&& ((pName[3] & ~0x20) == 'C')
			&& ((pName[4] & ~0x20) == 'K')
			&& (pName[5] == '$')
			&& !pName[6])
			    return true;
		    break;
		case 'O': /* COMx,  CON, CONIN$ CONOUT$ */
		    if ((pName[2] & ~0x20) == 'M') {
			if ((pName[3] >= '1') && (pName[3] <= '9')
			    && !pName[4])
			    return true;
		    }
		    else if ((pName[2] & ~0x20) == 'N') {
			if (!pName[3])
			    return true;
			else if ((pName[3] & ~0x20) == 'I') {
			    if (((pName[4] & ~0x20) == 'N')
				&& (pName[5] == '$')
				&& !pName[6])
			    return true;
			}
			else if ((pName[3] & ~0x20) == 'O') {
			    if (((pName[4] & ~0x20) == 'U')
				&& ((pName[5] & ~0x20) == 'T')
				&& (pName[6] == '$')
				&& !pName[7])
			    return true;
			}
		    }
		    break;
	    }
	    break;
	case 'L': /* LPTx */
	    if (((pName[1] & ~0x20) == 'U')
		&& ((pName[2] & ~0x20) == 'X')
		&& (pName[3] >= '1') && (pName[3] <= '9')
		&& !pName[4])
		    return true;
	    break;
	case 'N': /* NUL */
	    if (((pName[1] & ~0x20) == 'U')
		&& ((pName[2] & ~0x20) == 'L')
		&& !pName[3])
		    return true;
	    break;
	case 'P': /* PRN */
	    if (((pName[1] & ~0x20) == 'R')
		&& ((pName[2] & ~0x20) == 'N')
		&& !pName[3])
		    return true;
	    break;
    }
    return false;
}

WCHAR* VDir::MapPathW(const WCHAR *pInName)
{   /*
     * possiblities -- relative path or absolute path with or without drive letter
     * OR UNC name
     */
    WCHAR szBuffer[(MAX_PATH+1)*2];
    WCHAR szlBuf[MAX_PATH+1];
    int length = wcslen(pInName);

    if (!length)
	return (WCHAR*)pInName;

    if (length > MAX_PATH) {
	wcsncpy(szlBuf, pInName, MAX_PATH);
	if (IsPathSep(pInName[0]) && !IsPathSep(pInName[1])) {   
	    /* absolute path - reduce length by 2 for drive specifier */
	    szlBuf[MAX_PATH-2] = '\0';
	}
	else
	    szlBuf[MAX_PATH] = '\0';
	pInName = szlBuf;
    }
    /* strlen(pInName) is now <= MAX_PATH */

    if (pInName[1] == ':') {
	/* has drive letter */
	if (IsPathSep(pInName[2])) {
	    /* absolute with drive letter */
	    DoGetFullPathNameW((WCHAR*)pInName, (sizeof(szLocalBufferW)/sizeof(WCHAR)), szLocalBufferW);
	}
	else {
	    /* relative path with drive letter */
	    wcscpy(szBuffer, GetDirW(DriveIndex((char)*pInName)));
	    wcscat(szBuffer, &pInName[2]);
	    if(wcslen(szBuffer) > MAX_PATH)
		szBuffer[MAX_PATH] = '\0';

	    DoGetFullPathNameW(szBuffer, (sizeof(szLocalBufferW)/sizeof(WCHAR)), szLocalBufferW);
	}
    }
    else {
	/* no drive letter */
	if (IsPathSep(pInName[1]) && IsPathSep(pInName[0])) {
	    /* UNC name */
	    DoGetFullPathNameW((WCHAR*)pInName, (sizeof(szLocalBufferW)/sizeof(WCHAR)), szLocalBufferW);
	}
	else {
	    wcscpy(szBuffer, GetDefaultDirW());
	    if (IsPathSep(pInName[0])) {
		/* absolute path */
		wcscpy(&szBuffer[2], pInName);
		DoGetFullPathNameW(szBuffer, (sizeof(szLocalBufferW)/sizeof(WCHAR)), szLocalBufferW);
	    }
	    else {
		/* relative path */
		if (IsSpecialFileName(pInName)) {
		    return (WCHAR*)pInName;
		}
		else {
		    wcscat(szBuffer, pInName);
		    if (wcslen(szBuffer) > MAX_PATH)
			szBuffer[MAX_PATH] = '\0';

		    DoGetFullPathNameW(szBuffer, (sizeof(szLocalBufferW)/sizeof(WCHAR)), szLocalBufferW);
		}
	    }
	}
    }
    return szLocalBufferW;
}

int VDir::SetCurrentDirectoryW(WCHAR *lpBuffer)
{
    WCHAR *pPtr;
    int length, nRet = -1;

    pPtr = MapPathW(lpBuffer);
    length = wcslen(pPtr);
    if(length > 3 && IsPathSep(pPtr[length-1])) {
	/* don't remove the trailing slash from 'x:\'  */
	pPtr[length-1] = '\0';
    }

    DWORD r = GetFileAttributesW(pPtr);
    if ((r != 0xffffffff) && (r & FILE_ATTRIBUTE_DIRECTORY))
    {
	WCHAR wBuffer[(MAX_PATH+1)*2];
	DoGetFullPathNameW(pPtr, (sizeof(wBuffer)/sizeof(WCHAR)), wBuffer);
	SetDefaultDirW(wBuffer, DriveIndex((char)wBuffer[0]));
	nRet = 0;
    }

    return nRet;
}

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