761 lines
19 KiB
C
761 lines
19 KiB
C
/*****************************************************************************
|
|
* *
|
|
* FID.C *
|
|
* *
|
|
* Copyright (C) Microsoft Corporation 1989 - 1994. *
|
|
* All Rights reserved. *
|
|
* *
|
|
*****************************************************************************
|
|
* *
|
|
* Module Intent *
|
|
* *
|
|
* Low level file access layer, Windows version. *
|
|
* *
|
|
*****************************************************************************
|
|
* *
|
|
* Current Owner: UNDONE *
|
|
* *
|
|
*****************************************************************************
|
|
* *
|
|
* Released by Development: *
|
|
* *
|
|
*****************************************************************************/
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Revision History:
|
|
* -- Mar 92 adapted from WinHelp FID.C, DAVIDJES
|
|
* 9/26/95 davej Autodoc'd
|
|
* 3/05/97 erinfox Change errors to HRESULTS
|
|
*****************************************************************************/
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Issues:
|
|
* How to communicate super large (> DWORD) seeks over MOS. See FoSeekFid
|
|
*
|
|
*****************************************************************************/
|
|
|
|
static char s_aszModule[] = __FILE__; /* For error report */
|
|
|
|
#include <mvopsys.h>
|
|
#include <iterror.h>
|
|
|
|
#ifdef _32BIT
|
|
#define FP_OFF
|
|
#endif
|
|
|
|
#include <direct.h>
|
|
#include <orkin.h>
|
|
#include <misc.h>
|
|
#include <wrapstor.h>
|
|
#include <_mvutil.h>
|
|
|
|
#ifdef MOSMAP
|
|
#include <mapfile.h>
|
|
#endif
|
|
|
|
#ifndef _MAC
|
|
#include <dos.h> /* for FP_OFF macros and file attribute constants */
|
|
#endif
|
|
|
|
#include <io.h> /* for tell() and eof() */
|
|
#include <errno.h> /* this is for chsize() */
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* Defines
|
|
*
|
|
***************************************************************************/
|
|
|
|
#define UCBMAXRW ((WORD)0xFFFE)
|
|
#define LCBSIZESEG ((ULONG)0x10000)
|
|
|
|
/***************************************************************************
|
|
*
|
|
* Macros
|
|
*
|
|
***************************************************************************/
|
|
|
|
#define _WOpenMode(w) (_rgwOpenMode[ (w) & wRWMask ] | \
|
|
_rgwShare[ ((w) & wShareMask) >> wShareShift ] )
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* Private Functions
|
|
*
|
|
***************************************************************************/
|
|
|
|
HRESULT PASCAL FAR RcMapDOSErrorW(WORD);
|
|
|
|
/***************************************************************************
|
|
*
|
|
* Public Functions
|
|
*
|
|
***************************************************************************/
|
|
|
|
/***************************************************************************
|
|
* @doc INTERNAL
|
|
*
|
|
* @func BOOL PASCAL FAR | FidFlush |
|
|
*
|
|
* @parm FID |fid|
|
|
*
|
|
* @rdesc TRUE if file flushed OK, FALSE if could not flush.
|
|
*
|
|
***************************************************************************/
|
|
|
|
// Fill in non-win-32
|
|
|
|
PUBLIC BOOL PASCAL FAR FidFlush(FID fid)
|
|
{
|
|
BOOL bSuccess=TRUE;
|
|
#ifdef _WIN32
|
|
bSuccess=FlushFileBuffers(fid);
|
|
#else
|
|
Need code here
|
|
#endif
|
|
#ifdef _DEBUGMVFS
|
|
DPF2("FidFlush: fid %ld, returned %d\n", (LONG)fid, bSuccess);
|
|
#endif
|
|
return bSuccess;
|
|
}
|
|
|
|
/***************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func FID PASCAL FAR | FidCreateFm |
|
|
* Create a file
|
|
*
|
|
* @parm FM | fm |
|
|
* the file moniker
|
|
*
|
|
* @parm WORD | wOpenMode |
|
|
* read/write/share mode
|
|
*
|
|
* @parm WORD | wPerm |
|
|
* file permissions
|
|
*
|
|
* @parm PHRESULT | phr |
|
|
* Error return
|
|
*
|
|
* @rdesc fidNil on failure, valid fid otherwise
|
|
*
|
|
***************************************************************************/
|
|
|
|
PUBLIC FID FAR PASCAL FidCreateFm(FM fm, WORD wOpenMode,
|
|
WORD wPerm, PHRESULT phr)
|
|
{
|
|
#ifdef MOSMAP // {
|
|
// Disable function
|
|
SetErrCode(phr, ERR_NOTSUPPORTED);
|
|
return fidNil;
|
|
#else // } {
|
|
FID fid;
|
|
QAFM qafm;
|
|
|
|
if (fm == fmNil)
|
|
{
|
|
SetErrCode(phr, E_INVALIDARG);
|
|
return fidNil;
|
|
}
|
|
|
|
qafm = (QAFM)fm;
|
|
//qafm = _GLOBALLOCK((HANDLE)fm);
|
|
|
|
#ifdef _WIN32
|
|
fid = CreateFile((LPSTR)qafm->rgch,
|
|
((wOpenMode&wRead)?GENERIC_READ:0)|((wOpenMode&wWrite)?GENERIC_WRITE:0),
|
|
((wOpenMode&wShareRead)?FILE_SHARE_READ:0)|((wOpenMode&wShareWrite)?FILE_SHARE_WRITE:0),
|
|
NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
// Note: Some really cool optimizations can be made by specifying how the file
|
|
// is intended to be used!
|
|
#else
|
|
fid =_lcreat((LPSTR)qafm->rgch, _rgwPerm[ (wPerm) & wRWMask ]);
|
|
#endif
|
|
if (fid == fidNil)
|
|
SetErrCode(phr, E_FILECREATE);
|
|
//_GLOBALUNLOCK((HANDLE)fm);
|
|
#ifdef _DEBUGMVFS
|
|
DPF2("FidCreateFm: fid %ld for '%s'.\n", (LONG)fid, (LPSTR)qafm->rgch);
|
|
#endif
|
|
return fid;
|
|
#endif //}
|
|
}
|
|
|
|
/***************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func FID PASCAL FAR | FidOpenFm |
|
|
* Open a file in binary mode.
|
|
*
|
|
* @parm FM | fm |
|
|
* the file moniker
|
|
*
|
|
* @parm WORD | wOpenMode |
|
|
* read/write/share modes. Undefined if wRead and wWrite both unset.
|
|
*
|
|
* @parm PHRESULT | phr |
|
|
* Error return
|
|
*
|
|
* @rdesc fidNil on failure, else a valid FID.
|
|
*
|
|
***************************************************************************/
|
|
PUBLIC FID FAR PASCAL FidOpenFm(FM fm, WORD wOpenMode, PHRESULT phr)
|
|
{
|
|
FID fid;
|
|
QAFM qafm;
|
|
|
|
if (fm == fmNil)
|
|
{
|
|
SetErrCode(phr, E_INVALIDARG);
|
|
return fidNil;
|
|
}
|
|
|
|
qafm = (QAFM)fm;
|
|
//qafm = _GLOBALLOCK((HANDLE)fm);
|
|
|
|
#ifdef MOSMAP // {
|
|
// Open File Mapping, or get ref to existing one
|
|
if ((fid = (HFILE)MosOpenMapFile((LPSTR)qafm->rgch)) == fidNil)
|
|
SetErrCode(phr, ERR_FAILED);
|
|
#else // } {
|
|
|
|
#ifdef _WIN32
|
|
if ((fid = CreateFile((LPSTR)qafm->rgch,
|
|
((wOpenMode&wRead)?GENERIC_READ:0)|((wOpenMode&wWrite)?GENERIC_WRITE:0),
|
|
((wOpenMode&wShareRead)?FILE_SHARE_READ:0)|((wOpenMode&wShareWrite)?FILE_SHARE_WRITE:0),
|
|
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)) == fidNil)
|
|
#else
|
|
if ((fid = _lopen((LPSTR)qafm->rgch, _WOpenMode(wOpenMode))) == fidNil)
|
|
#endif // _WIN32
|
|
SetErrCode(phr, RcGetDOSError());
|
|
#endif //}
|
|
|
|
//_GLOBALUNLOCK((HANDLE)fm);
|
|
#ifdef _DEBUGMVFS
|
|
DPF2("FidOpenFm: fid %ld for '%s'.\n", (LONG)fid, (LPSTR)qafm->rgch);
|
|
#endif
|
|
return fid;
|
|
}
|
|
|
|
/***************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func LONG PASCAL FAR | LcbReadFid |
|
|
* Read data from a file.
|
|
*
|
|
* @parm FID | fid |
|
|
* valid FID of an open file
|
|
*
|
|
* @parm QV | qv |
|
|
* pointer to user's buffer assumed huge enough for data
|
|
*
|
|
* @parm LONG | lcb |
|
|
* count of bytes to read (must be less than 2147483648)
|
|
*
|
|
* @parm PHRESULT | phr |
|
|
* Error return
|
|
*
|
|
* @rdesc count of bytes actually read or -1 on error
|
|
*
|
|
***************************************************************************/
|
|
PUBLIC LONG FAR PASCAL LcbReadFid(FID fid, QV qv, LONG lcb, PHRESULT phr)
|
|
{
|
|
LONG lcbTotalRead = (LONG)0;
|
|
#ifdef MOSMAP // {
|
|
// Read map file
|
|
lcbTotalRead = MosReadMapFile((LPVOID)fid, qv, lcb) ;
|
|
if (lcbTotalRead == -1)
|
|
#else // } {
|
|
#ifdef _WIN32
|
|
|
|
if (!ReadFile(fid, qv, lcb, &lcbTotalRead, NULL))
|
|
SetErrCode(phr, RcGetDOSError());
|
|
|
|
#else
|
|
BYTE HUGE *hpb = (BYTE HUGE *)qv;
|
|
WORD ucb, ucbRead;
|
|
|
|
do {
|
|
ucb = (WORD)min(lcb, UCBMAXRW);
|
|
ucb = (WORD)min((ULONG) ucb, LCBSIZESEG - (ULONG) FP_OFF(hpb));
|
|
ucbRead = _lread(fid, hpb, ucb);
|
|
|
|
if (ucbRead == (WORD)-1)
|
|
{
|
|
if (!lcbTotalRead)
|
|
{
|
|
lcbTotalRead = (LONG)-1;
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
lcbTotalRead += ucbRead;
|
|
lcb -= ucbRead;
|
|
hpb += ucbRead;
|
|
}
|
|
} while (lcb > 0 && ucb == ucbRead);
|
|
|
|
if (ucbRead == (WORD)-1)
|
|
SetErrCode(phr, ERR_CANTREAD);
|
|
|
|
#endif
|
|
#endif //}
|
|
#ifdef _DEBUGMVFS
|
|
DPF2("LcbReadFid: fid %ld returned %ld bytes.\n", (LONG)fid, lcbTotalRead);
|
|
#endif
|
|
return lcbTotalRead;
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func LONG PASCAL FAR | LcbWriteid |
|
|
* Write data to a file.
|
|
*
|
|
* @parm FID | fid |
|
|
* valid FID of an open file
|
|
*
|
|
* @parm QV | qv |
|
|
* pointer to user's buffer assumed huge enough for data
|
|
*
|
|
* @parm LONG | lcb |
|
|
* count of bytes to read (must be less than 2147483648)
|
|
*
|
|
* @parm PHRESULT | phr |
|
|
* Error return
|
|
*
|
|
* @rdesc count of bytes actually read or -1 on error
|
|
*
|
|
***************************************************************************/
|
|
PUBLIC LONG FAR PASCAL LcbWriteFid(FID fid, QV qv, LONG lcb, PHRESULT phr)
|
|
{
|
|
LONG lcbTotalWrote = (LONG)0;
|
|
|
|
#ifdef MOSMAP // {
|
|
// Disable function
|
|
SetErrCode(phr, ERR_NOTSUPPORTED);
|
|
return 0;
|
|
#else // } {
|
|
#ifdef _WIN32
|
|
if (!WriteFile(fid, qv, lcb, &lcbTotalWrote, NULL))
|
|
SetErrCode(phr, RcGetDOSError());
|
|
|
|
#else
|
|
BYTE HUGE *hpb = (BYTE HUGE *)qv;
|
|
WORD ucb, ucbWrote;
|
|
|
|
if (lcb == 0L)
|
|
{
|
|
phr->err = S_OK;
|
|
return 0L;
|
|
}
|
|
|
|
do
|
|
{
|
|
ucb = (WORD)min(lcb, (ULONG) UCBMAXRW);
|
|
ucb = (WORD)min((ULONG) ucb, LCBSIZESEG - (WORD) FP_OFF(hpb));
|
|
ucbWrote = _lwrite(fid, hpb, ucb);
|
|
|
|
if (ucbWrote == (WORD)-1)
|
|
{
|
|
if (!lcbTotalWrote)
|
|
lcbTotalWrote = -1L;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
lcbTotalWrote += ucbWrote;
|
|
lcb -= ucbWrote;
|
|
hpb += ucbWrote;
|
|
}
|
|
} while (lcb > 0 && ucb == ucbWrote);
|
|
|
|
if (ucb != ucbWrote)
|
|
{
|
|
if (ucbWrote == (WORD)-1L)
|
|
SetErrCode (phr, RcGetDOSError());
|
|
else
|
|
SetErrCode (phr, E_DISKFULL);
|
|
}
|
|
#endif
|
|
#endif // }
|
|
#ifdef _DEBUGMVFS
|
|
DPF2("LcbWriteFid: fid %ld wrote %ld bytes.\n", (LONG)fid, lcbTotalWrote);
|
|
#endif
|
|
return lcbTotalWrote;
|
|
|
|
}
|
|
|
|
/***************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func HRESULT PASCAL FAR | RcCloseFid |
|
|
* Close a file.
|
|
*
|
|
* @parm FID | fid |
|
|
* valid FID of an open file
|
|
*
|
|
* @rdesc rcSuccess or something else
|
|
*
|
|
***************************************************************************/
|
|
PUBLIC HRESULT FAR PASCAL RcCloseFid(FID fid)
|
|
{
|
|
#ifdef MOSMAP // {
|
|
if (MosCloseMapFile((LPVOID)fid) == HFILE_ERROR)
|
|
{
|
|
#else // } {
|
|
#ifdef _WIN32
|
|
if (!CloseHandle(fid))
|
|
{
|
|
#else
|
|
if (_lclose( fid) == (HFILE)-1 )
|
|
{
|
|
#endif
|
|
#endif //}
|
|
#ifdef _DEBUGMVFS
|
|
DPF2("RcCloseFid: fid %ld was NOT closed(%d).\n", (LONG)fid, 0);
|
|
#endif
|
|
return E_FILECLOSE;
|
|
}
|
|
#ifdef _DEBUGMVFS
|
|
DPF2("RcCloseFid: fid %ld was closed(%d).\n", (LONG)fid, 1);
|
|
#endif
|
|
return S_OK;
|
|
}
|
|
|
|
/***************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func LONG PASCAL FAR | LTellFid |
|
|
* Return current file position in an open file.
|
|
*
|
|
* @parm FID | fid |
|
|
* valid FID of an open file
|
|
*
|
|
* @parm PHRESULT | phr |
|
|
* Error return
|
|
*
|
|
* @rdesc offset from beginning of file in bytes; -1L on error.
|
|
*
|
|
***************************************************************************/
|
|
LONG FAR PASCAL LTellFid(FID fid, PHRESULT phr)
|
|
{
|
|
LONG l;
|
|
|
|
#ifdef MOSMAP // {
|
|
l = MosSeekMapFile((LPVOID)fid, 0L, 1) ;
|
|
#else // } {
|
|
#ifdef _WIN32
|
|
DWORD dwHigh = 0L;
|
|
l = SetFilePointer(fid, 0L, &dwHigh, FILE_CURRENT);
|
|
// OK, just plain no support for +4gig files here...
|
|
if ((l==(LONG)-1L) || (dwHigh))
|
|
SetErrCode(phr, E_FILESEEK);
|
|
#else
|
|
l = _llseek(fid, 0L, 1);
|
|
#endif
|
|
#endif //}
|
|
if ( l == (LONG)-1L )
|
|
SetErrCode(phr, E_FILESEEK);
|
|
#ifdef _DEBUGMVFS
|
|
DPF2("LTellFid: fid %ld is at %ld\n", (LONG)fid, l);
|
|
#endif
|
|
return l;
|
|
}
|
|
|
|
/***************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func LONG PASCAL FAR | LSeekFid |
|
|
* Move file pointer to a specified location. It is an error
|
|
* to seek before beginning of file, but not to seek past end
|
|
* of file.
|
|
*
|
|
* @parm FID | fid |
|
|
* valid FID of an open file
|
|
*
|
|
* @parm LONG | lPos |
|
|
* offset from origin
|
|
*
|
|
* @parm WORD | wOrg |
|
|
* one of: wSeekSet: beginning of file, wSeekCur: current file pos,
|
|
* wSeekEnd: end of file
|
|
*
|
|
* @parm PHRESULT | phr |
|
|
* Error return
|
|
*
|
|
* @rdesc offset in bytes from beginning of file or -1L on error
|
|
*
|
|
***************************************************************************/
|
|
|
|
PUBLIC LONG FAR PASCAL LSeekFid(FID fid, LONG lPos, WORD wOrg, PHRESULT phr)
|
|
{
|
|
LONG l;
|
|
#ifdef MOSMAP // {
|
|
l = MosSeekMapFile((LPVOID)fid, lPos, wOrg) ;
|
|
#else // } {
|
|
#ifdef _WIN32
|
|
DWORD dwHigh = 0L;
|
|
l = SetFilePointer(fid, lPos, &dwHigh, wOrg);
|
|
// OK, just plain no support for +4gig files here...
|
|
if ((l!=lPos) || (dwHigh))
|
|
SetErrCode(phr, E_FILESEEK);
|
|
#else
|
|
l = _llseek(fid, lPos, wOrg);
|
|
if (l == (LONG)-1L)
|
|
SetErrCode(phr, E_FILESEEK);
|
|
#endif
|
|
#endif //}
|
|
#ifdef _DEBUGMVFS
|
|
DPF2("LSeekFid: fid %ld is at %ld\n", (LONG)fid, l);
|
|
#endif
|
|
return l;
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func FILEOFFSET PASCAL FAR | FoSeekFid |
|
|
* Move file pointer to a specified location. It is an error
|
|
* to seek before beginning of file, but not to seek past end
|
|
* of file. This function is meant to handle offsets larger than 4
|
|
* gigabytes.
|
|
*
|
|
* @parm FID | fid |
|
|
* valid FID of an open file
|
|
*
|
|
* @parm FILEOFFSET | foPos |
|
|
* offset from origin
|
|
*
|
|
* @parm WORD | wOrg |
|
|
* one of: wSeekSet: beginning of file, wSeekCur: current file pos,
|
|
* wSeekEnd: end of file
|
|
*
|
|
* @parm PHRESULT | phr |
|
|
* Error return
|
|
*
|
|
* @rdesc offset in bytes from beginning of file or -1L on error
|
|
*
|
|
***************************************************************************/
|
|
PUBLIC FILEOFFSET FAR PASCAL FoSeekFid(FID fid, FILEOFFSET foPos, WORD wOrg, PHRESULT phr)
|
|
{
|
|
DWORD dw;
|
|
DWORD dwHigh=0L;
|
|
FILEOFFSET foSeeked;
|
|
|
|
#ifdef MOSMAP // {
|
|
SetErrCode(phr,ERR_NOTSUPPORTED);
|
|
return -1L;
|
|
//l = MosSeekMapFile((LPVOID)fid, lPos, wOrg) ;
|
|
#else // } {
|
|
#ifdef _WIN32
|
|
dwHigh=(LONG)foPos.dwHigh;
|
|
dw = SetFilePointer((HANDLE)fid, foPos.dwOffset, &dwHigh, wOrg);
|
|
#else // not really supported for 16-bit
|
|
dw = (DWORD)_llseek(fid, foPos.dwOffset, wOrg);
|
|
#endif
|
|
#endif //}
|
|
foSeeked.dwOffset=dw;
|
|
foSeeked.dwHigh=dwHigh;
|
|
if (dw == (LONG)-1L)
|
|
{
|
|
if (GetLastError()!=NO_ERROR)
|
|
SetErrCode(phr, E_FILESEEK);
|
|
else
|
|
*phr = S_OK;
|
|
}
|
|
#ifdef _DEBUGMVFS
|
|
DPF2("FoSeekFid: fid %ld is at %ld\n", (LONG)fid, foPos.dwOffset);
|
|
#endif
|
|
return foSeeked;
|
|
}
|
|
|
|
|
|
#if 0
|
|
#if !defined ( _WIN32 )
|
|
/***************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func BOOL PASCAL FAR | FEofFid |
|
|
* Tells ye if ye're at the end of the file.
|
|
*
|
|
* @parm FID | fid |
|
|
* valid FID of an open file
|
|
*
|
|
* @rdesc TRUE if at EOF, FALSE if not or error has occurred (?)
|
|
*
|
|
***************************************************************************/
|
|
PUBLIC BOOL PASCAL FAR FEofFid(FID fid)
|
|
{
|
|
WORD wT;
|
|
|
|
if (( wT = eof( fid) ) == (WORD)-1 )
|
|
SetErrCode(RcGetDOSError());
|
|
else
|
|
SetErrCode(rcSuccess);
|
|
|
|
return (BOOL)(wT == 1);
|
|
}
|
|
#endif // !defined ( _WIN32 )
|
|
#endif
|
|
|
|
PUBLIC HRESULT PASCAL FAR RcGetDOSError (void)
|
|
{
|
|
|
|
#ifdef _WIN32
|
|
// NT does not support errno in the multi threaded environment.
|
|
|
|
switch( GetLastError() )
|
|
{
|
|
case NO_ERROR:
|
|
return S_OK;
|
|
|
|
case ERROR_ACCESS_DENIED:
|
|
return E_NOPERMISSION;
|
|
|
|
case ERROR_INVALID_HANDLE:
|
|
return E_HANDLE;
|
|
|
|
case ERROR_HANDLE_DISK_FULL:
|
|
case ERROR_DISK_FULL:
|
|
return E_DISKFULL;
|
|
|
|
default:
|
|
return E_INVALIDARG;
|
|
}
|
|
#else
|
|
switch (errno) {
|
|
case EACCES:
|
|
return E_NOPERMISSION;
|
|
break;
|
|
|
|
case EBADF:
|
|
return E_INVALIDARG;
|
|
break;
|
|
|
|
case ENOSPC:
|
|
return E_DISKFULL;
|
|
break;
|
|
|
|
default:
|
|
return E_INVALIDARG;
|
|
break;
|
|
}
|
|
#endif // _WIN32
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func HRESULT PASCAL FAR | RcChSizeFid |
|
|
* Change the size of a file
|
|
*
|
|
* @parm FID | fid |
|
|
* valid FID of an open file
|
|
*
|
|
* @parm LONG | lcb |
|
|
* New size of file
|
|
*
|
|
* @rdesc Returns S_OK if all OK, else the error.
|
|
*
|
|
***************************************************************************/
|
|
PUBLIC HRESULT PASCAL FAR RcChSizeFid(FID fid, LONG lcb)
|
|
{
|
|
#if !defined ( _WIN32 )
|
|
if (chsize( fid, lcb) == -1 )
|
|
return RcGetDOSError();
|
|
else
|
|
#endif // !defined ( _WIN32 )
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func HRESULT PASCAL FAR | RcUnlinkFm |
|
|
* Delete a DOS file given the filename
|
|
*
|
|
* @parm FM | fm |
|
|
* Name of file to remove. (An FM is the same as an LPSTR).
|
|
*
|
|
* @rdesc Returns S_OK if all OK, else the error.
|
|
*
|
|
***************************************************************************/
|
|
PUBLIC HRESULT PASCAL FAR EXPORT_API RcUnlinkFm(FM fm)
|
|
{
|
|
#ifdef MOSMAP // {
|
|
// Disable function
|
|
return ERR_NOTSUPPORTED;
|
|
#else // } {
|
|
QAFM qafm = (QAFM)fm;
|
|
//QAFM qafm = _GLOBALLOCK((HANDLE)fm);
|
|
OFSTRUCT ofStruct;
|
|
int fRet = S_OK;
|
|
|
|
if (OpenFile((LPSTR)qafm->rgch, &ofStruct, OF_DELETE) == HFILE_ERROR)
|
|
fRet = E_FILEDELETE;
|
|
//_GLOBALUNLOCK((HANDLE)fm);
|
|
return fRet;
|
|
#endif // }
|
|
}
|
|
|
|
|
|
#ifdef _IT_FULL_CRT // {
|
|
#ifndef _MAC // {
|
|
/* This function was previously present in dlgopen.c. It has been brought */
|
|
/* here as it is making INT21 call. */
|
|
/***************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func BOOL PASCAL FAR | FDriveOk |
|
|
* Cheks if the drive specified with thwe file name is OK.
|
|
*
|
|
* @parm LPSTR | szFile |
|
|
* Name of file
|
|
*
|
|
* @rdesc TRUE if drive is OK.
|
|
*
|
|
***************************************************************************/
|
|
PUBLIC BOOL PASCAL FAR EXPORT_API FDriveOk(LPSTR szFile)
|
|
/* -- Check if drive is valid */
|
|
{
|
|
// the static variables here are static only because we are in a DLL
|
|
// and need to pass a near pointer to them to a C Run-Time routine.
|
|
// These should be Locally-Alloc'd so they don't waste space in
|
|
// our data segment.
|
|
|
|
static int wDiskCur;
|
|
int wDisk;
|
|
|
|
wDiskCur = _getdrive();
|
|
|
|
/* change to new disk if specified */
|
|
if ((wDisk = (int)((*szFile & 0xdf) - ('A' - 1))) != wDiskCur) {
|
|
if (_chdrive (wDisk) == (int)-1)
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
#endif // } _MAC
|
|
#endif // }
|