/************************************************************/
/* Windows Write, Copyright 1985-1992 Microsoft Corporation */
/************************************************************/
/* fileres.c -- functions from file.c that are usually resident */
#define NOCLIPBOARD
#define NOGDICAPMASKS
#define NOCTLMGR
#define NOVIRTUALKEYCODES
#define NOWINMESSAGES
#define NOWINSTYLES
#define NOSYSMETRICS
#define NOMENUS
#define NOICON
#define NOKEYSTATE
#define NORASTEROPS
#define NOSHOWWINDOW
#define NOSYSCOMMANDS
#define NOATOM
#define NOCOLOR
#define NOCREATESTRUCT
#define NOCTLMGR
#define NODRAWTEXT
#define NOMETAFILE
#define NOMSG
#define NOHDC
#define NOGDI
#define NOMB
#define NOFONT
#define NOPEN
#define NOBRUSH
#define NOWNDCLASS
#define NOSOUND
#define NOCOMM
#define NOPOINT
#define NORECT
#define NOREGION
#define NOSCROLL
#define NOTEXTMETRIC
#define NOWH
#define NOWINOFFSETS
#include <windows.h>
#include "mw.h"
#include "doslib.h"
#define NOUAC
#include "cmddefs.h"
#include "docdefs.h"
#include "filedefs.h"
#include "str.h"
#include "debug.h"
extern int vfDiskFull;
extern int vfSysFull;
extern int vfnWriting;
extern CHAR (*rgbp)[cbSector];
extern typeTS tsMruRfn;
extern struct BPS *mpibpbps;
extern int ibpMax;
extern struct FCB (**hpfnfcb)[];
extern typeTS tsMruBps;
extern struct ERFN dnrfn[rfnMax];
extern int iibpHashMax;
extern CHAR *rgibpHash;
extern int rfnMac;
extern int ferror;
extern CHAR szWriteDocPrompt[];
extern CHAR szScratchFilePrompt[];
extern CHAR szSaveFilePrompt[];
#define IibpHash(fn,pn) ((int) ((fn + 1) * (pn + 1)) & 077777) % iibpHashMax
#ifdef DEBUG
#define STATIC
#else
#define STATIC static
#define ErrorWithMsg( idpmt, szModule ) Error( idpmt )
#define DiskErrorWithMsg( idpmt, szModule ) DiskError( idpmt )
#endif
#define osfnNil (-1)
CHAR *PchFromFc(fn, fc, pcch)
int fn;
typeFC fc;
int *pcch;
{ /*
Description: Reads from a file, starting at virtual character
position fc. Reads until end of buffer page.
Returns: Pointer to char buffer starting at fc.
The number of characters read is returned in *pcch.
*/
int dfc;
CHAR *pch;
typePN pn;
int ibp;
struct BPS *pbps;
dfc = (int) (fc % cfcPage);
pn = (typePN) (fc / cfcPage);
ibp = IbpEnsureValid(fn, pn);
pbps = &mpibpbps[ibp];
*pcch = pbps->cch - dfc;
return &rgbp[ibp][dfc];
}
/* end of P c h F r o m F c */
/*** PchGetPn - Assure file page loaded, return pointer
*
*/
CHAR *PchGetPn(fn, pn, pcch, fWrite)
int fn;
typePN pn;
int *pcch;
BOOL fWrite; // missing before?? (2.11.91) D. Kent
{ /*
Description: Get char pointer to page buffer, option to mark
page as dirty.
Returns: Pointer to buffer.
cch in *pcch
*/
int ibp = IbpEnsureValid(fn, pn);
struct BPS *pbps = &mpibpbps[ibp];
*pcch = pbps->cch;
pbps->fDirty |= fWrite;
return rgbp[ibp];
} /* end of P c h G e t P n */
int IbpEnsureValid(fn, pn)
int fn;
typePN pn;
{ /*
Description: Get page pn of file fn into memory.
If already in memory, return.
Returns: Bp index (buffer slot #) where the page resides
in memory.
*/
int ibp;
register struct BPS *pbps;
#ifdef DEBUG
CheckIbp();
#endif /* DEBUG */
/* Is the page currently in memory? */
ibp = rgibpHash[IibpHash(fn,pn)];
/* ibp is the first in a linked list of possible matches */
/* resident in memory */
Scribble(3,'V');
while (ibp != ibpNil) /* while not end of linked list */
{ /* check if any buffers in memory match */
pbps = &mpibpbps[ibp];
if (pbps->fn == fn && pbps->pn == pn)
{ /* Found it */
pbps->ts = ++tsMruBps; /* mark page as MRUsed */
Scribble(3,' ');
return ibp;
}
ibp = pbps->ibpHashNext;
}
/* page is not currently in memory */
return IbpMakeValid( fn, pn );
} /* end of I b p E n s u r e V a l i d */
CloseEveryRfn( fHardToo )
{ /* Close all files we have open. Close only files on removable media
if fHardToo is FALSE; ALL files if fHardToo is TRUE */
int rfn;
for (rfn = 0; rfn < rfnMac; rfn++)
{
int fn = dnrfn [rfn].fn;
if (fn != fnNil)
if ( fHardToo ||
!((POFSTRUCT)((**hpfnfcb)[fn].rgbOpenFileBuf))->fFixedDisk )
{
CloseRfn( rfn );
}
}
}
typeFC FcWScratch(pch, cch)
CHAR *pch;
int cch;
{ /*
Description: Write chars at end of scratch file.
Returns: first fc written.
*/
typeFC fc = (**hpfnfcb)[fnScratch].fcMac;
#if 0
extern BOOL bNo64KLimit;
if ((!bNo64KLimit) && (((long) fc) + ((long) cch) > 65536L)) /* scratch file to big */
{
DiskErrorWithMsg(IDPMTSFER, " FcWScratch"); /* session too long */
vfSysFull = fTrue;
/* recovery is accomplished: all that happens is that a few
characters do not get written to the scratch file - the
user loses only a little bit of his work. */
}
else
#endif
WriteRgch(fnScratch, pch, cch);
return fc;
}
WriteRgch(fn, pch, cch)
int fn;
CHAR *pch;
int cch;
{ /*
Description: Writes char string pch, length cch, to end of
file fn.
Returns: nothing
*/
extern vfDiskError;
struct FCB *pfcb = &(**hpfnfcb)[fn];
typePN pn = (typePN) (pfcb->fcMac / cfcPage);
#ifdef WIN30
/* Error checking was horrendous in these early days, right?
Ha. It still is. In any case, don't know WHAT we can do
if the page number has gotten too large, so just fake a
disk error so that IbpEnsureValid() doesn't go off into
never-never land! This catch effectively limits us to
4M files ..pault 11/1/89 */
if (pn > pgnMax)
#ifdef DEBUG
DiskErrorWithMsg(IDPMTSDE2, "writergch");
#else
DiskError(IDPMTSDE2);
#endif
else
#endif
while (cch > 0)
{ /* One page at a time */
int ibp = IbpEnsureValid(fn, pn++);
struct BPS *pbps = &mpibpbps[ibp];
int cchBp = pbps->cch;
int cchBlt = min((int)cfcPage - cchBp, cch);
Assert( vfDiskError ||
cchBp == pfcb->fcMac - (pn - 1) * cfcPage);
bltbyte(pch, &rgbp[ibp][cchBp], cchBlt);
pbps->cch += cchBlt;
pbps->fDirty = true;
pfcb->fcMac += cchBlt;
pfcb->pnMac = pn;
pch += cchBlt;
cch -= cchBlt;
}
} /* end of W r i t e R g c h */
CloseRfn( rfn )
int rfn;
{/*
Description: Close a file and delete its Rfn entry
Returns: nothing
*/
struct ERFN *perfn = &dnrfn[rfn];
int fn = perfn->fn;
Assert (rfn >= 0 &&
rfn < rfnMac &&
perfn->osfn != osfnNil &&
fn != fnNil);
#ifdef DEBUG
#ifdef DFILE
CommSzSz( "Closing file: ", &(**(**hpfnfcb)[fn].hszFile)[0] );
#endif
#endif
/* Close may fail if windows already closed the file for us,
but that's OK */
FCloseDoshnd( perfn->osfn );
{ /* Just like the statement below, but 28 bytes less
under CMERGE V13 */
REG1 struct FCB *pfcb = &(**hpfnfcb) [fn];
pfcb->rfn = rfnNil;
}
/* (**hpfnfcb)[fn].rfn = rfnNil; */
perfn->fn = fnNil;
}
