mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
828 lines
17 KiB
828 lines
17 KiB
/*
|
|
| SCC Viewer Technology - Source file
|
|
|
|
|
| Code: SCCIO.C
|
|
| Module: SCCUT
|
|
| Developer: Phil Boutros
|
|
| Function: Handles access to files
|
|
|
|
|
| Added OLE2 doc support, 7-11-94, Randal Chao
|
|
| Added IOTYPE_ISTREAM and IOTYPE_ISTORAGE implementation, Aug 94 -Geoff
|
|
*/
|
|
|
|
#define XUT
|
|
#include <PLATFORM.H>
|
|
#include <SCCUT.H>
|
|
#include <SCCIO.H>
|
|
#include "sccio.pro"
|
|
|
|
|
|
#ifdef WIN16
|
|
#ifdef SCCFEATURE_OLE2
|
|
#include "sccio_ow.c"
|
|
#else
|
|
#include "sccio_w.c"
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef WIN32
|
|
#include "sccio_n.c"
|
|
#endif
|
|
|
|
#ifdef MAC
|
|
#include "sccio_m.c"
|
|
#endif
|
|
|
|
#ifdef OS2
|
|
#include "sccio_o.c"
|
|
#endif
|
|
|
|
#ifndef SCCFEATURE_OLE2
|
|
#include "sccio_ss.c"
|
|
#endif
|
|
|
|
IO_ENTRYSC IOERR IO_ENTRYMOD IORangeClose(HIOFILE hFile)
|
|
{
|
|
PIORANGEFILE locIOPtr = (PIORANGEFILE) hFile;
|
|
HANDLE locThis;
|
|
|
|
IOSeek(locIOPtr->hFile,IOSEEK_TOP,locIOPtr->dwSavedPos);
|
|
locThis = locIOPtr->hThis;
|
|
UTGlobalUnlock(locThis);
|
|
UTGlobalFree(locThis);
|
|
|
|
return(IOERR_OK);
|
|
}
|
|
|
|
IO_ENTRYSC IOERR IO_ENTRYMOD IORangeRead(HIOFILE hFile, BYTE FAR * pData, DWORD dwSize, DWORD FAR * pCount)
|
|
{
|
|
PIORANGEFILE locIOPtr = (PIORANGEFILE) hFile;
|
|
IOERR locRet;
|
|
DWORD dwTmpOffset;
|
|
|
|
if ((locRet = IOTell(locIOPtr->hFile, &dwTmpOffset)) == IOERR_OK)
|
|
{
|
|
if (dwTmpOffset < locIOPtr->dwFirstByte || dwTmpOffset > locIOPtr->dwLastByte + 1 )
|
|
locRet = IOERR_SEEKOUTOFRANGE;
|
|
else if (dwTmpOffset + dwSize > locIOPtr->dwLastByte + 1 )
|
|
dwSize = locIOPtr->dwLastByte - dwTmpOffset + 1;
|
|
locRet = IORead(locIOPtr->hFile, pData, dwSize, pCount);
|
|
}
|
|
|
|
return(locRet);
|
|
}
|
|
|
|
IO_ENTRYSC IOERR IO_ENTRYMOD IORangeWrite(HIOFILE hFile, BYTE FAR * pData, DWORD dwSize, DWORD FAR * pCount)
|
|
{
|
|
PIORANGEFILE locIOPtr = (PIORANGEFILE) hFile;
|
|
IOERR locRet = IOERR_OK;
|
|
|
|
return(locRet);
|
|
}
|
|
|
|
IO_ENTRYSC IOERR IO_ENTRYMOD IORangeSeek(HIOFILE hFile, WORD wFrom, LONG lOffset)
|
|
{
|
|
PIORANGEFILE locIOPtr = (PIORANGEFILE) hFile;
|
|
IOERR locRet;
|
|
LONG lCurOffset;
|
|
|
|
locRet = IOERR_OK;
|
|
|
|
switch(wFrom)
|
|
{
|
|
case IOSEEK_TOP:
|
|
lOffset += locIOPtr->dwFirstByte;
|
|
break;
|
|
|
|
case IOSEEK_CURRENT:
|
|
wFrom = IOSEEK_TOP;
|
|
locRet = IOTell(locIOPtr->hFile, &lCurOffset);
|
|
lOffset = lCurOffset + lOffset;
|
|
break;
|
|
|
|
case IOSEEK_BOTTOM:
|
|
wFrom = IOSEEK_TOP;
|
|
lOffset = locIOPtr->dwLastByte - lOffset + 1;
|
|
break;
|
|
}
|
|
|
|
if (locRet == IOERR_OK)
|
|
{
|
|
if ( (DWORD)lOffset < locIOPtr->dwFirstByte || (DWORD)lOffset > locIOPtr->dwLastByte + 1 )
|
|
locRet = IOERR_SEEKOUTOFRANGE;
|
|
else
|
|
locRet = IOSeek(locIOPtr->hFile, wFrom, lOffset);
|
|
}
|
|
|
|
return(locRet);
|
|
}
|
|
|
|
IO_ENTRYSC IOERR IO_ENTRYMOD IORangeTell(HIOFILE hFile, DWORD FAR * pOffset)
|
|
{
|
|
PIORANGEFILE locIOPtr = (PIORANGEFILE) hFile;
|
|
IOERR locRet;
|
|
|
|
if ((locRet = IOTell(locIOPtr->hFile, pOffset)) == IOERR_OK )
|
|
*pOffset -= locIOPtr->dwFirstByte;
|
|
|
|
return(locRet);
|
|
}
|
|
|
|
IO_ENTRYSC IOERR IO_ENTRYMOD IORangeGetInfo(HIOFILE hFile, DWORD dwInfoId, VOID FAR * pInfo)
|
|
{
|
|
PIORANGEFILE locIOPtr = (PIORANGEFILE) hFile;
|
|
IOERR locRet;
|
|
|
|
locRet = IOGetInfo(locIOPtr->hFile,dwInfoId,pInfo);
|
|
return(locRet);
|
|
}
|
|
|
|
IO_ENTRYSC IOERR IO_ENTRYMOD IOCreate(HIOFILE FAR * phFile, DWORD dwType, LPVOID pSpec, DWORD dwFlags)
|
|
{
|
|
IOERR locRet;
|
|
HIOFILE locFileHnd;
|
|
HIOSPEC locSpecHnd;
|
|
HIOSPEC locTempSpecHnd;
|
|
|
|
locRet = IOAllocSpec(dwType,pSpec,&locSpecHnd);
|
|
|
|
if (locRet == IOERR_OK)
|
|
{
|
|
switch (dwType)
|
|
{
|
|
case IOTYPE_DOSPATH:
|
|
case IOTYPE_ANSIPATH:
|
|
case IOTYPE_UNICODEPATH:
|
|
case IOTYPE_MACPATH:
|
|
case IOTYPE_MACFSSPEC:
|
|
case IOTYPE_MACHFS:
|
|
|
|
locRet = IOCreateNP(&locFileHnd, locSpecHnd, dwFlags);
|
|
break;
|
|
|
|
case IOTYPE_TEMP:
|
|
|
|
locRet = IOGenTempSpecNP(locSpecHnd,&locTempSpecHnd);
|
|
dwFlags |= IOOPEN_DELETEONCLOSE; // Geoff 6-7-95
|
|
|
|
if (locRet == IOERR_OK)
|
|
{
|
|
UTGlobalFree(locSpecHnd);
|
|
locSpecHnd = locTempSpecHnd;
|
|
locRet = IOCreateNP(&locFileHnd, locSpecHnd, dwFlags);
|
|
}
|
|
|
|
break;
|
|
|
|
case IOTYPE_RANGE:
|
|
default:
|
|
locRet = IOERR_INVALIDSPEC;
|
|
break;
|
|
}
|
|
|
|
if (locRet != IOERR_OK)
|
|
{
|
|
UTGlobalFree(locSpecHnd);
|
|
}
|
|
else
|
|
{
|
|
*phFile = locFileHnd;
|
|
}
|
|
}
|
|
|
|
return(locRet);
|
|
}
|
|
|
|
|
|
#ifdef SCCFEATURE_OLE2
|
|
//Hey!, This is using the real OLE2, old stuff
|
|
|
|
IO_ENTRYSC IOERR IO_ENTRYMOD IOOpen(HIOFILE FAR * phFile, DWORD dwType, LPVOID pSpec, DWORD dwFlags)
|
|
{
|
|
IOERR locRet;
|
|
HANDLE locIOHnd;
|
|
PIORANGEFILE locIORangePtr;
|
|
HIOSPEC locSpecHnd;
|
|
HIOSPEC locSecSpecHnd;
|
|
|
|
switch (dwType)
|
|
{
|
|
case IOTYPE_DOSPATH:
|
|
case IOTYPE_ANSIPATH:
|
|
case IOTYPE_UNICODEPATH:
|
|
case IOTYPE_MACPATH:
|
|
case IOTYPE_MACFSSPEC:
|
|
case IOTYPE_MACHFS:
|
|
case IOTYPE_SUBSTORAGE:
|
|
case IOTYPE_SUBSTREAM:
|
|
|
|
locRet = IOAllocSpec(dwType,pSpec,&locSpecHnd);
|
|
|
|
if (locRet == IOERR_OK)
|
|
{
|
|
locRet = IOOpenNP(phFile, locSpecHnd, dwFlags);
|
|
|
|
if (locRet != IOERR_OK)
|
|
{
|
|
UTGlobalFree(locSpecHnd);
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case IOTYPE_SECONDARY:
|
|
|
|
locRet = IOAllocSpec(dwType,pSpec,&locSpecHnd);
|
|
|
|
if (locRet == IOERR_OK)
|
|
{
|
|
locRet = IOGenSecSpec(locSpecHnd,&locSecSpecHnd);
|
|
|
|
if (locRet == IOERR_OK)
|
|
{
|
|
locRet = IOOpenNP(phFile, locSecSpecHnd, dwFlags);
|
|
|
|
if (locRet != IOERR_OK)
|
|
{
|
|
UTGlobalFree(locSecSpecHnd);
|
|
}
|
|
}
|
|
|
|
UTGlobalFree(locSpecHnd);
|
|
}
|
|
|
|
break;
|
|
|
|
case IOTYPE_ISTREAM: // Geoff, 8-3-94
|
|
locRet = IOOpenIStreamNP(phFile, pSpec, dwFlags);
|
|
break;
|
|
|
|
case IOTYPE_ISTORAGE: // Geoff, 8-5-94
|
|
locRet = IOOpenIStorageNP(phFile, pSpec, dwFlags);
|
|
break;
|
|
|
|
case IOTYPE_RANGE:
|
|
|
|
locIOHnd = UTGlobalAlloc(sizeof(IORANGEFILE));
|
|
|
|
if (locIOHnd)
|
|
{
|
|
locIORangePtr = (PIORANGEFILE) UTGlobalLock(locIOHnd);
|
|
|
|
locIORangePtr->sBaseIO.pClose = IORangeClose;
|
|
locIORangePtr->sBaseIO.pRead = IORangeRead;
|
|
locIORangePtr->sBaseIO.pWrite = IORangeWrite;
|
|
locIORangePtr->sBaseIO.pSeek = IORangeSeek;
|
|
locIORangePtr->sBaseIO.pTell = IORangeTell;
|
|
locIORangePtr->sBaseIO.pGetInfo = IORangeGetInfo;
|
|
locIORangePtr->sBaseIO.pOpen = IOOpen;
|
|
locIORangePtr->dwFlags = 0;
|
|
locIORangePtr->hFile = ((PIOSPECRANGE)pSpec)->hRefFile;
|
|
locIORangePtr->dwFirstByte = ((PIOSPECRANGE)pSpec)->dwFirstByte;
|
|
locIORangePtr->dwLastByte = ((PIOSPECRANGE)pSpec)->dwLastByte;
|
|
locIORangePtr->hThis = locIOHnd;
|
|
IOTell(locIORangePtr->hFile,&(locIORangePtr->dwSavedPos));
|
|
IOSeek(locIORangePtr->hFile,IOSEEK_TOP,locIORangePtr->dwFirstByte);
|
|
|
|
*phFile = (HIOFILE) locIORangePtr;
|
|
|
|
locRet = IOERR_OK;
|
|
}
|
|
else
|
|
{
|
|
locRet = IOERR_ALLOCFAIL;
|
|
}
|
|
|
|
break;
|
|
|
|
case IOTYPE_REDIRECT:
|
|
|
|
*phFile = (HIOFILE) pSpec;
|
|
|
|
#ifdef WINDOWS
|
|
locRet = IOHandleRedirectNP(phFile);
|
|
#else
|
|
locRet = IOERR_OK;
|
|
#endif //WINDOWS
|
|
|
|
break;
|
|
|
|
case IOTYPE_TEMP:
|
|
default:
|
|
locRet = IOERR_INVALIDSPEC;
|
|
break;
|
|
}
|
|
|
|
return(locRet);
|
|
}
|
|
|
|
#else
|
|
//Hey Hey! This is using the new, advanced native-born structured storage system!
|
|
IO_ENTRYSC IOERR IO_ENTRYMOD IOOpen(HIOFILE FAR * phFile, DWORD dwType, LPVOID pSpec, DWORD dwFlags)
|
|
{
|
|
IOERR locRet;
|
|
HANDLE locIOHnd;
|
|
PIORANGEFILE locIORangePtr;
|
|
HIOSPEC locSpecHnd;
|
|
HIOSPEC locSecSpecHnd;
|
|
|
|
switch (dwType)
|
|
{
|
|
case IOTYPE_DOSPATH:
|
|
case IOTYPE_ANSIPATH:
|
|
case IOTYPE_UNICODEPATH:
|
|
case IOTYPE_MACPATH:
|
|
case IOTYPE_MACFSSPEC:
|
|
case IOTYPE_MACHFS:
|
|
if (IOERR_OK == (locRet = IOAllocSpec(dwType, pSpec, &locSpecHnd)))
|
|
{
|
|
locRet = IOOpenNP (phFile, locSpecHnd, dwFlags);
|
|
if (IOERR_OK != locRet)
|
|
UTGlobalFree (locSpecHnd);
|
|
else if (IOERR_TRUE == IOIsOLE2RootStorage (*phFile)) // Check if it is OLE2
|
|
{
|
|
if (IOERR_OK != (locRet = IOOpenOLE2RootStorage (phFile, locSpecHnd, dwFlags)))
|
|
locRet = IOERR_OK; // Open as flat file instead
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IOTYPE_SUBSTORAGE:
|
|
if (IOERR_OK == (locRet = IOAllocSpec (dwType, pSpec, &locSpecHnd)))
|
|
{
|
|
if (IOERR_OK != (locRet = IOOpenOLE2SubStorage(phFile, locSpecHnd, dwFlags)))
|
|
UTGlobalFree (locSpecHnd);
|
|
}
|
|
break;
|
|
|
|
|
|
case IOTYPE_SUBSTREAM:
|
|
if (IOERR_OK == (locRet = IOAllocSpec (dwType, pSpec, &locSpecHnd)))
|
|
{
|
|
if (IOERR_OK != (locRet = IOOpenOLE2SubStream(phFile, locSpecHnd, dwFlags)))
|
|
UTGlobalFree (locSpecHnd);
|
|
}
|
|
break;
|
|
|
|
|
|
case IOTYPE_SECONDARY:
|
|
|
|
locRet = IOAllocSpec(dwType,pSpec,&locSpecHnd);
|
|
|
|
if (locRet == IOERR_OK)
|
|
{
|
|
locRet = IOGenSecSpec(locSpecHnd,&locSecSpecHnd);
|
|
|
|
if (locRet == IOERR_OK)
|
|
{
|
|
locRet = IOOpenNP(phFile, locSecSpecHnd, dwFlags);
|
|
|
|
if (locRet != IOERR_OK)
|
|
{
|
|
UTGlobalFree(locSecSpecHnd);
|
|
}
|
|
}
|
|
|
|
UTGlobalFree(locSpecHnd);
|
|
}
|
|
|
|
break;
|
|
|
|
case IOTYPE_RANGE:
|
|
|
|
locIOHnd = UTGlobalAlloc(sizeof(IORANGEFILE));
|
|
|
|
if (locIOHnd)
|
|
{
|
|
locIORangePtr = (PIORANGEFILE) UTGlobalLock(locIOHnd);
|
|
|
|
locIORangePtr->sBaseIO.pClose = IORangeClose;
|
|
locIORangePtr->sBaseIO.pRead = IORangeRead;
|
|
locIORangePtr->sBaseIO.pWrite = IORangeWrite;
|
|
locIORangePtr->sBaseIO.pSeek = IORangeSeek;
|
|
locIORangePtr->sBaseIO.pTell = IORangeTell;
|
|
locIORangePtr->sBaseIO.pGetInfo = IORangeGetInfo;
|
|
locIORangePtr->sBaseIO.pOpen = IOOpen;
|
|
locIORangePtr->dwFlags = 0;
|
|
locIORangePtr->hFile = ((PIOSPECRANGE)pSpec)->hRefFile;
|
|
locIORangePtr->dwFirstByte = ((PIOSPECRANGE)pSpec)->dwFirstByte;
|
|
locIORangePtr->dwLastByte = ((PIOSPECRANGE)pSpec)->dwLastByte;
|
|
locIORangePtr->hThis = locIOHnd;
|
|
IOTell(locIORangePtr->hFile,&(locIORangePtr->dwSavedPos));
|
|
IOSeek(locIORangePtr->hFile,IOSEEK_TOP,locIORangePtr->dwFirstByte);
|
|
|
|
*phFile = (HIOFILE) locIORangePtr;
|
|
|
|
locRet = IOERR_OK;
|
|
}
|
|
else
|
|
{
|
|
locRet = IOERR_ALLOCFAIL;
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
case IOTYPE_REDIRECT:
|
|
case IOTYPE_TEMP:
|
|
default:
|
|
locRet = IOERR_INVALIDSPEC;
|
|
break;
|
|
}
|
|
|
|
return(locRet);
|
|
}
|
|
#endif
|
|
|
|
|
|
IOERR IOAllocSpec(DWORD dwType, LPVOID pSpec, HANDLE FAR * phSpec)
|
|
{
|
|
IOERR locRet;
|
|
HANDLE locSpecHnd;
|
|
PIOSPEC locSpecPtr;
|
|
WORD locSize;
|
|
|
|
locRet = IOERR_OK;
|
|
|
|
switch (dwType)
|
|
{
|
|
case IOTYPE_DOSPATH:
|
|
case IOTYPE_ANSIPATH:
|
|
case IOTYPE_MACPATH:
|
|
|
|
locSize = UTstrlen((LPSTR)pSpec)+1;
|
|
break;
|
|
|
|
case IOTYPE_UNICODEPATH:
|
|
#ifdef WIN32
|
|
locSize = (wcslen((LPWSTR)pSpec)+1) * sizeof(WORD);
|
|
#endif
|
|
break;
|
|
|
|
#ifdef MAC
|
|
case IOTYPE_MACFSSPEC:
|
|
|
|
locSize = sizeof(FSSpec);
|
|
break;
|
|
#endif
|
|
|
|
case IOTYPE_MACHFS:
|
|
|
|
locSize = sizeof(IOSPECMACHFS);
|
|
break;
|
|
|
|
case IOTYPE_TEMP:
|
|
|
|
locSize = 4;
|
|
break;
|
|
|
|
case IOTYPE_RANGE:
|
|
|
|
locSize = sizeof(IOSPECRANGE);
|
|
break;
|
|
|
|
case IOTYPE_SECONDARY:
|
|
|
|
locSize = sizeof(IOSPECSECONDARY);
|
|
break;
|
|
|
|
case IOTYPE_SUBSTREAM:
|
|
|
|
locSize = sizeof(IOSPECSUBSTREAM);
|
|
break;
|
|
|
|
case IOTYPE_SUBSTORAGE:
|
|
|
|
locSize = sizeof(IOSPECSUBSTORAGE);
|
|
break;
|
|
|
|
default:
|
|
locRet = IOERR_INVALIDSPEC;
|
|
break;
|
|
}
|
|
|
|
if (locRet == IOERR_OK)
|
|
{
|
|
locSpecHnd = UTGlobalAlloc(sizeof(IOSPEC)+locSize);
|
|
|
|
if (locSpecHnd != NULL)
|
|
{
|
|
locSpecPtr = UTGlobalLock(locSpecHnd);
|
|
|
|
locSpecPtr->dwType = dwType;
|
|
UTmemcpy(locSpecPtr->uTypes.aGen,pSpec,locSize);
|
|
|
|
UTGlobalUnlock(locSpecHnd);
|
|
|
|
*phSpec = locSpecHnd;
|
|
}
|
|
else
|
|
{
|
|
locRet = IOERR_ALLOCFAIL;
|
|
}
|
|
}
|
|
|
|
return(locRet);
|
|
}
|
|
|
|
|
|
IOERR IOGenSecSpec(HANDLE hSecSpec, HANDLE FAR * phOutSpec)
|
|
{
|
|
IOERR locRet;
|
|
PIOFILE locIOPtr;
|
|
PIOSPEC locSecSpecPtr;
|
|
PIOSPEC locRefSpecPtr;
|
|
BYTE locPath[512];
|
|
BYTE FAR * locStartPtr;
|
|
BYTE FAR * locScanPtr;
|
|
IOSPECMACHFS locMacHfs;
|
|
|
|
locSecSpecPtr = UTGlobalLock(hSecSpec);
|
|
|
|
if (locSecSpecPtr)
|
|
{
|
|
locIOPtr = (PIOFILE)locSecSpecPtr->uTypes.sSecondary.hRefFile;
|
|
|
|
locRefSpecPtr = UTGlobalLock(locIOPtr->hSpec);
|
|
|
|
if (locRefSpecPtr)
|
|
{
|
|
switch (locRefSpecPtr->dwType)
|
|
{
|
|
case IOTYPE_DOSPATH:
|
|
case IOTYPE_ANSIPATH:
|
|
|
|
UTstrcpy(locPath,locRefSpecPtr->uTypes.szDosPath);
|
|
|
|
locStartPtr = locScanPtr = locPath;
|
|
|
|
while (*locScanPtr != 0x00)
|
|
locScanPtr++;
|
|
while (*locScanPtr != '\\' && *locScanPtr != '//' && *locScanPtr != ':' && locScanPtr != locStartPtr)
|
|
locScanPtr--;
|
|
if (locScanPtr != locStartPtr)
|
|
locScanPtr++;
|
|
|
|
UTstrcpy(locScanPtr,locSecSpecPtr->uTypes.sSecondary.szFileName);
|
|
|
|
locRet = IOAllocSpec(locRefSpecPtr->dwType, &locPath, phOutSpec);
|
|
|
|
break;
|
|
|
|
case IOTYPE_MACPATH:
|
|
|
|
UTstrcpy(locPath,locRefSpecPtr->uTypes.szMacPath);
|
|
|
|
locStartPtr = locScanPtr = locPath;
|
|
|
|
while (*locScanPtr != 0x00)
|
|
locScanPtr++;
|
|
while (*locScanPtr != ':' && locScanPtr != locStartPtr)
|
|
locScanPtr--;
|
|
if (locScanPtr != locStartPtr)
|
|
locScanPtr++;
|
|
|
|
UTstrcpy(locScanPtr,locSecSpecPtr->uTypes.sSecondary.szFileName);
|
|
|
|
locRet = IOAllocSpec(locRefSpecPtr->dwType, &locPath, phOutSpec);
|
|
|
|
break;
|
|
|
|
case IOTYPE_MACHFS:
|
|
|
|
locMacHfs = locRefSpecPtr->uTypes.sMacHfs;
|
|
|
|
UTstrcpy(locMacHfs.fileName,locSecSpecPtr->uTypes.sSecondary.szFileName);
|
|
|
|
locRet = IOAllocSpec(locRefSpecPtr->dwType, &locMacHfs, phOutSpec);
|
|
|
|
break;
|
|
|
|
case IOTYPE_MACFSSPEC:
|
|
|
|
#ifdef MAC
|
|
{
|
|
FSSpec locMacFsSpec;
|
|
|
|
locMacFsSpec = locRefSpecPtr->uTypes.sMacFsSpec;
|
|
|
|
UTstrcpy(locMacFsSpec.name,locSecSpecPtr->uTypes.sSecondary.szFileName);
|
|
c2pstr(locMacFsSpec.name);
|
|
|
|
locRet = IOAllocSpec(locRefSpecPtr->dwType, &locMacFsSpec, phOutSpec);
|
|
}
|
|
#endif
|
|
|
|
default:
|
|
locRet = IOERR_INVALIDSPEC;
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
return(locRet);
|
|
}
|
|
|
|
|
|
IOERR IOGetFileName(HIOSPEC hSpec,BYTE FAR * pFileName)
|
|
{
|
|
IOERR locRet;
|
|
PIOSPEC locSpecPtr;
|
|
BYTE FAR * locStartPtr;
|
|
BYTE FAR * locScanPtr;
|
|
|
|
if (hSpec == NULL)
|
|
return(IOERR_INVALIDSPEC);
|
|
|
|
locRet = IOERR_OK;
|
|
|
|
locSpecPtr = UTGlobalLock(hSpec);
|
|
|
|
switch (locSpecPtr->dwType)
|
|
{
|
|
case IOTYPE_DOSPATH:
|
|
|
|
locStartPtr = locScanPtr = locSpecPtr->uTypes.szDosPath;
|
|
|
|
while (*locScanPtr != 0x00)
|
|
locScanPtr++;
|
|
while (*locScanPtr != '\\' && *locScanPtr != '//' && *locScanPtr != ':' && locScanPtr != locStartPtr)
|
|
locScanPtr--;
|
|
if (locScanPtr != locStartPtr)
|
|
locScanPtr++;
|
|
|
|
UTstrcpy(pFileName,locScanPtr);
|
|
|
|
break;
|
|
|
|
case IOTYPE_ANSIPATH:
|
|
|
|
locStartPtr = locScanPtr = locSpecPtr->uTypes.szAnsiPath;
|
|
|
|
while (*locScanPtr != 0x00)
|
|
locScanPtr++;
|
|
while (*locScanPtr != '\\' && *locScanPtr != '//' && *locScanPtr != ':' && locScanPtr != locStartPtr)
|
|
locScanPtr--;
|
|
if (locScanPtr != locStartPtr)
|
|
locScanPtr++;
|
|
|
|
UTstrcpy(pFileName,locScanPtr);
|
|
|
|
break;
|
|
|
|
case IOTYPE_MACPATH:
|
|
|
|
locStartPtr = locScanPtr = locSpecPtr->uTypes.szMacPath;
|
|
|
|
while (*locScanPtr != 0x00)
|
|
locScanPtr++;
|
|
while (*locScanPtr != ':' && locScanPtr != locStartPtr)
|
|
locScanPtr--;
|
|
if (locScanPtr != locStartPtr)
|
|
locScanPtr++;
|
|
|
|
UTstrcpy(pFileName,locScanPtr);
|
|
|
|
break;
|
|
|
|
case IOTYPE_MACHFS:
|
|
|
|
UTstrcpy(pFileName,locSpecPtr->uTypes.sMacHfs.fileName);
|
|
break;
|
|
|
|
case IOTYPE_MACFSSPEC:
|
|
|
|
#ifdef MAC
|
|
p2cstr(locSpecPtr->uTypes.sMacFsSpec.name);
|
|
UTstrcpy(pFileName,locSpecPtr->uTypes.sMacFsSpec.name);
|
|
c2pstr(locSpecPtr->uTypes.sMacFsSpec.name);
|
|
break;
|
|
#endif /*MAC*/
|
|
|
|
|
|
case IOTYPE_UNICODEPATH:
|
|
#ifdef WIN32
|
|
// For compatibility with our IO system, I'm coding this to return
|
|
// single-byte characters. This may need to be changed or expanded
|
|
// in the future, eh? -Geoff, 8-23-94
|
|
|
|
// I'm also taking the chance that the string will not overflow
|
|
// the target buffer, which is a gamble on platforms that support
|
|
// long file names. THIS WILL HAVE TO BE CHANGED!
|
|
{
|
|
LPWSTR startPtr;
|
|
LPWSTR scanPtr;
|
|
|
|
startPtr = scanPtr = (LPWSTR)locSpecPtr->uTypes.szUnicodePath;
|
|
|
|
while (*scanPtr != 0x00)
|
|
scanPtr++;
|
|
|
|
while (*scanPtr != (WCHAR)'\\' &&
|
|
*scanPtr != (WCHAR)'//' &&
|
|
*scanPtr != (WCHAR)':' &&
|
|
scanPtr != startPtr)
|
|
{
|
|
scanPtr--;
|
|
}
|
|
|
|
if (scanPtr != startPtr)
|
|
scanPtr++;
|
|
|
|
WideCharToMultiByte( CP_ACP, 0,
|
|
(LPCWSTR)scanPtr,
|
|
-1, pFileName,
|
|
wcslen(scanPtr)+1, NULL, NULL );
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
case IOTYPE_RANGE:
|
|
case IOTYPE_TEMP:
|
|
default:
|
|
locRet = IOERR_INVALIDSPEC;
|
|
break;
|
|
}
|
|
|
|
UTGlobalUnlock(hSpec);
|
|
// Added comment
|
|
return(locRet);
|
|
}
|
|
|
|
|
|
IOERR IOGetPathName(HIOSPEC hSpec,BYTE FAR * pPathName)
|
|
{
|
|
IOERR locRet;
|
|
PIOSPEC locSpecPtr;
|
|
|
|
if (hSpec == NULL)
|
|
return(IOERR_INVALIDSPEC);
|
|
|
|
locRet = IOERR_OK;
|
|
|
|
locSpecPtr = UTGlobalLock(hSpec);
|
|
|
|
switch (locSpecPtr->dwType)
|
|
{
|
|
case IOTYPE_DOSPATH:
|
|
|
|
UTstrcpy(pPathName,locSpecPtr->uTypes.szDosPath);
|
|
|
|
break;
|
|
|
|
case IOTYPE_ANSIPATH:
|
|
|
|
UTstrcpy(pPathName,locSpecPtr->uTypes.szAnsiPath);
|
|
|
|
break;
|
|
|
|
case IOTYPE_MACPATH:
|
|
|
|
UTstrcpy(pPathName,locSpecPtr->uTypes.szMacPath);
|
|
|
|
break;
|
|
|
|
case IOTYPE_MACHFS:
|
|
|
|
UTstrcpy(pPathName,locSpecPtr->uTypes.sMacHfs.fileName);
|
|
break;
|
|
|
|
case IOTYPE_MACFSSPEC:
|
|
|
|
#ifdef MAC
|
|
p2cstr(locSpecPtr->uTypes.sMacFsSpec.name);
|
|
UTstrcpy(pPathName,locSpecPtr->uTypes.sMacFsSpec.name);
|
|
c2pstr(locSpecPtr->uTypes.sMacFsSpec.name);
|
|
break;
|
|
#endif /*MAC*/
|
|
|
|
|
|
case IOTYPE_UNICODEPATH:
|
|
#ifdef WIN32
|
|
// For compatibility with our IO system, I'm coding this to return
|
|
// single-byte characters. This may need to be changed or expanded
|
|
// in the future, eh? -Geoff, 8-23-94
|
|
|
|
// I'm also taking the chance that the string will not overflow
|
|
// the target buffer, which is a gamble on platforms that support
|
|
// long file names. THIS WILL HAVE TO BE CHANGED!
|
|
|
|
WideCharToMultiByte( CP_ACP, 0,
|
|
(LPCWSTR)locSpecPtr->uTypes.szUnicodePath,
|
|
-1, pPathName,
|
|
wcslen(locSpecPtr->uTypes.szUnicodePath)+1, NULL, NULL );
|
|
|
|
break;
|
|
#endif
|
|
|
|
case IOTYPE_RANGE:
|
|
case IOTYPE_TEMP:
|
|
default:
|
|
locRet = IOERR_INVALIDSPEC;
|
|
break;
|
|
}
|
|
|
|
UTGlobalUnlock(hSpec);
|
|
// Added comment
|
|
return(locRet);
|
|
}
|