[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___

const int driveCount = 30;

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;
	}
	return lpBuffer;
    };
    inline WCHAR* GetCurrentDirectoryW(int dwBufSize, WCHAR *lpBuffer)
    {
	WCHAR* ptr = dirTableW[nDefault];
	while (dwBufSize--)
	{
	    if ((*lpBuffer++ = *ptr++) == '\0')
		break;
	}
	return lpBuffer;
    };


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

protected:
    int SetDirA(char const *pPath, int index);
    void FromEnvA(char *pEnv, int index);
    inline const char *GetDefaultDirA(void)
    {
	return dirTableA[nDefault];
    };

    inline void SetDefaultDirA(char const *pPath, int index)
    {
	SetDirA(pPath, index);
	nDefault = index;
    };
    int SetDirW(WCHAR const *pPath, int 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)
    {
	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;
    DWORD driveBits;
    int nSave;
    char szBuffer[MAX_PATH*driveCount];

    pMem = p;
    if (pDir) {
	for (index = 0; index < driveCount; ++index) {
	    SetDirW(pDir->GetDirW(index), index);
	}
	nDefault = pDir->GetDefault();
    }
    else {
	nSave = bManageDirectory;
	bManageDirectory = 0;
	driveBits = GetLogicalDrives();
	if (GetLogicalDriveStrings(sizeof(szBuffer), szBuffer)) {
	    char* pEnv = GetEnvironmentStrings();
	    char* ptr = szBuffer;
	    for (index = 0; index < driveCount; ++index) {
		if (driveBits & (1<<index)) {
		    ptr += SetDirA(ptr, index) + 1;
		    FromEnvA(pEnv, index);
		}
	    }
	    FreeEnvironmentStrings(pEnv);
	}
	SetDefaultA(".");
	bManageDirectory = nSave;
    }
}

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::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;
    char szBuffer[MAX_PATH+1];
    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) {
	    wcscpy(ptr, pPath);
	    ptr += length-1;
	    chr = *ptr++;
	    if (chr != '\\' && chr != '/') {
		*ptr++ = '\\';
		*ptr = '\0';
	    }
	    WideCharToMultiByte(CP_ACP, 0, dirTableW[index], -1, szBuffer, sizeof(szBuffer), NULL, NULL);
	    length = strlen(szBuffer);
	    pMem->Free(dirTableA[index]);
	    dirTableA[index] = (char*)pMem->Malloc(length+1);
	    if (dirTableA[index] != NULL) {
		strcpy(dirTableA[index], szBuffer);
	    }
	}
    }

    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];

    if (strlen(pInName) > 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 */
	    strcpy(szLocalBufferA, pInName);
	}
	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 */
	    strcpy(szLocalBufferA, pInName);
	}
	else {
	    strcpy(szBuffer, GetDefaultDirA());
	    if (IsPathSep(pInName[0])) {
		/* absolute path */
		szLocalBufferA[0] = szBuffer[0];
		szLocalBufferA[1] = szBuffer[1];
		strcpy(&szLocalBufferA[2], pInName);
	    }
	    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)
{
    HANDLE hHandle;
    WIN32_FIND_DATA win32FD;
    char szBuffer[MAX_PATH+1], *pPtr;
    int length, nRet = -1;

    GetFullPathNameA(MapPathA(lpBuffer), sizeof(szBuffer), szBuffer, &pPtr);
    /* if the last char is a '\\' or a '/' then add
     * an '*' before calling FindFirstFile
     */
    length = strlen(szBuffer);
    if(length > 0 && IsPathSep(szBuffer[length-1])) {
	szBuffer[length] = '*';
	szBuffer[length+1] = '\0';
    }

    hHandle = FindFirstFileA(szBuffer, &win32FD);
    if (hHandle != INVALID_HANDLE_VALUE) {
        FindClose(hHandle);

	/* if an '*' was added remove it */
	if(szBuffer[length] == '*')
	    szBuffer[length] = '\0';

	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]) + 4;  /* add 1 for trailing NULL and 3 for '=d=' */
	}
    }
    return dwSize;
}

LPSTR VDir::BuildEnvironmentSpace(LPSTR lpStr)
{   /* store the current directory environment strings as '=d=d:\path' */
    int index;
    LPSTR lpDirStr;
    for (index = 0; index < driveCount; ++index) {
	lpDirStr = dirTableA[index];
	if (lpDirStr != NULL) {
	    lpStr[0] = '=';
	    lpStr[1] = lpDirStr[0];
	    lpStr[2] = '=';
	    strcpy(&lpStr[3], lpDirStr);
	    lpStr += strlen(lpDirStr) + 4; /* add 1 for trailing NULL and 3 for '=d=' */
	}
    }
    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];

    if (wcslen(pInName) > 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 */
	    wcscpy(szLocalBufferW, pInName);
	}
	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 */
	    wcscpy(szLocalBufferW, pInName);
	}
	else {
	    wcscpy(szBuffer, GetDefaultDirW());
	    if (IsPathSep(pInName[0])) {
		/* absolute path */
		szLocalBufferW[0] = szBuffer[0];
		szLocalBufferW[1] = szBuffer[1];
		wcscpy(&szLocalBufferW[2], pInName);
	    }
	    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)
{
    HANDLE hHandle;
    WIN32_FIND_DATAW win32FD;
    WCHAR szBuffer[MAX_PATH+1], *pPtr;
    int length, nRet = -1;

    GetFullPathNameW(MapPathW(lpBuffer), (sizeof(szBuffer)/sizeof(WCHAR)), szBuffer, &pPtr);
    /* if the last char is a '\\' or a '/' then add
     * an '*' before calling FindFirstFile
     */
    length = wcslen(szBuffer);
    if(length > 0 && IsPathSep(szBuffer[length-1])) {
	szBuffer[length] = '*';
	szBuffer[length+1] = '\0';
    }

    hHandle = FindFirstFileW(szBuffer, &win32FD);
    if (hHandle != INVALID_HANDLE_VALUE) {
        FindClose(hHandle);

	/* if an '*' was added remove it */
	if(szBuffer[length] == '*')
	    szBuffer[length] = '\0';

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