1488 lines
36 KiB
C
1488 lines
36 KiB
C
|
/************************************************************/
|
|||
|
|
/* Windows Write, Copyright 1985-1992 Microsoft Corporation */
|
|||
|
|
/************************************************************/
|
|||
|
|
|
|||
|
|
/* file.c -- WRITE file interface functions */
|
|||
|
|
/* It is important that the external interface to this module be entirely
|
|||
|
|
at the level of "fn's", not "osfn's" and/or "rfn's". An intermodule call
|
|||
|
|
may cause our files to be closed, and this is the only module internally
|
|||
|
|
capable of compensating for this */
|
|||
|
|
|
|||
|
|
#define NOGDICAPMASKS
|
|||
|
|
#define NOVIRTUALKEYCODES
|
|||
|
|
#define NOWINMESSAGES
|
|||
|
|
#define NOWINSTYLES
|
|||
|
|
#define NOSYSMETRICS
|
|||
|
|
#define NOMENUS
|
|||
|
|
#define NOICON
|
|||
|
|
#define NOKEYSTATE
|
|||
|
|
#define NOSYSCOMMANDS
|
|||
|
|
#define NORASTEROPS
|
|||
|
|
#define NOSHOWWINDOW
|
|||
|
|
#define NOSYSMETRICS
|
|||
|
|
#define NOATOM
|
|||
|
|
#define NOBITMAP
|
|||
|
|
#define NOBRUSH
|
|||
|
|
#define NOCLIPBOARD
|
|||
|
|
#define NOCOLOR
|
|||
|
|
#define NOCREATESTRUCT
|
|||
|
|
#define NOCTLMGR
|
|||
|
|
#define NODRAWTEXT
|
|||
|
|
#define NOFONT
|
|||
|
|
#define NOGDI
|
|||
|
|
#define NOHDC
|
|||
|
|
#define NOMEMMGR
|
|||
|
|
#define NOMENUS
|
|||
|
|
#define NOMETAFILE
|
|||
|
|
#define NOMSG
|
|||
|
|
#define NOPEN
|
|||
|
|
#define NOPOINT
|
|||
|
|
#define NORECT
|
|||
|
|
#define NOREGION
|
|||
|
|
#define NOSCROLL
|
|||
|
|
#define NOSOUND
|
|||
|
|
#define NOTEXTMETRIC
|
|||
|
|
#define NOWH
|
|||
|
|
#define NOWINOFFSETS
|
|||
|
|
#define NOWNDCLASS
|
|||
|
|
#define NOCOMM
|
|||
|
|
#include <windows.h>
|
|||
|
|
|
|||
|
|
#include "mw.h"
|
|||
|
|
#include "doslib.h"
|
|||
|
|
#include "docdefs.h"
|
|||
|
|
#include "filedefs.h"
|
|||
|
|
#define NOSTRUNDO
|
|||
|
|
#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[];
|
|||
|
|
|
|||
|
|
|
|||
|
|
#ifdef CKSM
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
extern unsigned (**hpibpcksm) [];
|
|||
|
|
extern int ibpCksmMax;
|
|||
|
|
#endif
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
|
|||
|
|
#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)
|
|||
|
|
|
|||
|
|
STATIC int near RfnGrab( void );
|
|||
|
|
STATIC int near FpeSeekFnPn( int, typePN );
|
|||
|
|
STATIC typeOSFN near OsfnEnsureValid( int );
|
|||
|
|
STATIC typeOSFN near OsfnReopenFn( int );
|
|||
|
|
STATIC CHAR *(near SzPromptFromFn( int ));
|
|||
|
|
|
|||
|
|
/* The following debug flags are used to initiate, during debug, specific
|
|||
|
|
low-level disk errors */
|
|||
|
|
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
int vfFakeReadErr = 0;
|
|||
|
|
int vfFakeWriteErr = 0;
|
|||
|
|
int vfFakeOpenErr = 0;
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
|
|||
|
|
#ifdef CKSM
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
unsigned CksmFromIbp( ibp )
|
|||
|
|
int ibp;
|
|||
|
|
{
|
|||
|
|
int cb = mpibpbps [ibp].cch;
|
|||
|
|
unsigned cksm = 0;
|
|||
|
|
CHAR *pb;
|
|||
|
|
|
|||
|
|
Assert( ibp >= 0 && ibp < ibpCksmMax );
|
|||
|
|
Assert( mpibpbps [ibp].fn != fnNil );
|
|||
|
|
Assert( !mpibpbps [ibp].fDirty );
|
|||
|
|
|
|||
|
|
pb = rgbp [ibp];
|
|||
|
|
while (cb-- > 0)
|
|||
|
|
cksm += *(pb++);
|
|||
|
|
|
|||
|
|
return cksm;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
typeFC FcMacFromUnformattedFn( fn )
|
|||
|
|
int fn;
|
|||
|
|
{ /* Obtain fcMac for passed unformatted fn by seeking to the file's end.
|
|||
|
|
If it fails, return -1
|
|||
|
|
If it succeeds, return the fcMac */
|
|||
|
|
typeFC fcMac;
|
|||
|
|
typeOSFN osfn;
|
|||
|
|
|
|||
|
|
Assert( (fn != fnNil) && (!(**hpfnfcb) [fn].fFormatted) );
|
|||
|
|
|
|||
|
|
if ((osfn = OsfnEnsureValid( fn )) == osfnNil)
|
|||
|
|
return (typeFC) -1;
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
if ( FIsErrDwSeek( fcMac=DwSeekDw( osfn, 0L, SF_END )))
|
|||
|
|
{
|
|||
|
|
if (fcMac == fpeBadHndError)
|
|||
|
|
{ /* Windows closed the file for us */
|
|||
|
|
if ( ((osfn = OsfnReopenFn( fn )) != osfnNil) &&
|
|||
|
|
!FIsErrDwSeek( fcMac = DwSeekDw( osfn, 0L, SF_END )) )
|
|||
|
|
/* Successfully re-opened file */
|
|||
|
|
return fcMac;
|
|||
|
|
}
|
|||
|
|
if (FIsCaughtDwSeekErr( fcMac ))
|
|||
|
|
/* Suppress reporting of error -- Windows did it */
|
|||
|
|
ferror = TRUE;
|
|||
|
|
DiskErrorWithMsg(IDPMTSDE, " FcMacFromUnformattedFn");
|
|||
|
|
return (typeFC) -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return fcMac;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
IbpLru(ibpStarting)
|
|||
|
|
int ibpStarting;
|
|||
|
|
/*
|
|||
|
|
Description: Find least recently used BPS (Buffer page) starting
|
|||
|
|
at slot ibpStarting.
|
|||
|
|
Returns: Number of the least recently used buffer slot.
|
|||
|
|
*/
|
|||
|
|
{
|
|||
|
|
int ibp, ibpLru = 0;
|
|||
|
|
typeTS ts, tsLru;
|
|||
|
|
struct BPS *pbps = &mpibpbps[ibpStarting];
|
|||
|
|
|
|||
|
|
tsLru = -1; /* Since time stamps are unsigned ints, -1 */
|
|||
|
|
/* is largest time stamp. */
|
|||
|
|
for(ibp = ibpStarting; ibp < ibpMax; ibp++, pbps++)
|
|||
|
|
{
|
|||
|
|
ts = pbps->ts - (tsMruBps + 1);
|
|||
|
|
/* The time stamp can conceivably wrap around and thus a */
|
|||
|
|
/* simple < or > comparison between time stamps cannot be */
|
|||
|
|
/* used to determine which is more or less recently used. */
|
|||
|
|
/* The above statement normalizes time stamps so that the */
|
|||
|
|
/* most recently used is FFFF and the others fall between */
|
|||
|
|
/* 0 and FFFE. This method makes the assumption that */
|
|||
|
|
/* time stamps older than 2^16 clicks of the time stamp */
|
|||
|
|
/* counter have long since disappeared. Otherwise, such */
|
|||
|
|
/* ancients would appear to be what they are not. */
|
|||
|
|
if (ts <= tsLru) {tsLru = ts; ibpLru = ibp;}
|
|||
|
|
}
|
|||
|
|
return(ibpLru);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
int IbpMakeValid(fn, pn)
|
|||
|
|
int fn;
|
|||
|
|
typePN pn;
|
|||
|
|
{ /*
|
|||
|
|
Description: Get page pn of file fn into memory.
|
|||
|
|
Assume not already in memory.
|
|||
|
|
Returns: Bp index (buffer slot #) where the page resides
|
|||
|
|
in memory.
|
|||
|
|
*/
|
|||
|
|
#define cbpClump 4
|
|||
|
|
|
|||
|
|
#define cpnAlign 4
|
|||
|
|
#define ALIGN
|
|||
|
|
|
|||
|
|
int ibpT, cbpRead;
|
|||
|
|
int ibp, iibpHash, ibpPrev;
|
|||
|
|
typePN pnT;
|
|||
|
|
register struct BPS *pbps;
|
|||
|
|
int ibpNew;
|
|||
|
|
int cch;
|
|||
|
|
int fFileFlushed;
|
|||
|
|
#ifdef ALIGN
|
|||
|
|
int dibpAlign;
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
int cbpReadT;
|
|||
|
|
CheckIbp();
|
|||
|
|
#endif /* DEBUG */
|
|||
|
|
Assert(fn != fnNil);
|
|||
|
|
|
|||
|
|
/* page is not currently in memory */
|
|||
|
|
|
|||
|
|
/* We will try to read in cbpClump Buffer Pages beginning with the
|
|||
|
|
least recently used */
|
|||
|
|
|
|||
|
|
/* Pick best starting slot for read based on a least-recently-used scheme */
|
|||
|
|
|
|||
|
|
if (vfnWriting != fnNil)
|
|||
|
|
/* Currently saving file, favor adjacent slots for fn being written */
|
|||
|
|
ibpNew = IbpWriting( fn );
|
|||
|
|
else
|
|||
|
|
/* If reading from the scratch file, do not use the first
|
|||
|
|
cpbMustKeep slots. This is necessary to prevent a disk full
|
|||
|
|
condition from being catastrophic. */
|
|||
|
|
ibpNew = IbpLru( (fn == fnScratch) ? cbpMustKeep : 0 );
|
|||
|
|
|
|||
|
|
|
|||
|
|
/* Empty the slots by flushing out ALL buffers holding pieces of their fn's */
|
|||
|
|
/* Compute cbpRead */
|
|||
|
|
pbps = &mpibpbps[ ibpNew ];
|
|||
|
|
for ( cbpRead = 0; cbpRead < min( cbpClump, ibpMax - ibpNew );
|
|||
|
|
cbpRead++, pbps++ )
|
|||
|
|
{
|
|||
|
|
#ifdef CKSM
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
int ibpT = pbps - mpibpbps;
|
|||
|
|
|
|||
|
|
if (!pbps->fDirty && pbps->fn != fnNil)
|
|||
|
|
Assert( (**hpibpcksm) [ibpT] == CksmFromIbp( ibpT ) );
|
|||
|
|
#endif
|
|||
|
|
#endif
|
|||
|
|
if (pbps->fDirty && pbps->fn != fnNil)
|
|||
|
|
if (!FFlushFn( pbps->fn ))
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* If a flush failed, cbpRead was reduced. If it was reduced to 0, this
|
|||
|
|
is serious. If the file was not fnScratch, we can consider it flushed
|
|||
|
|
even though the flush failed, because upper-level procedures will detect
|
|||
|
|
the error and cancel the operation. If it was fnScratch, we must obtain
|
|||
|
|
a new slot for the page we are trying to read */
|
|||
|
|
if (cbpRead == 0)
|
|||
|
|
{
|
|||
|
|
if (pbps->fn == fnScratch)
|
|||
|
|
ibpNew = IbpFindSlot( fn );
|
|||
|
|
cbpRead++;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{ /* Restrict cbpRead according to the following:
|
|||
|
|
(1) If we are reading in the text area, we don't want to
|
|||
|
|
free pages for stuff past the end of the text area
|
|||
|
|
that we know CchPageIn won't give us
|
|||
|
|
(2) If we are reading in the properties area, we only want to
|
|||
|
|
read one page, because FetchCp depends on us not trashing
|
|||
|
|
the MRU page */
|
|||
|
|
struct FCB *pfcb = &(**hpfnfcb)[fn];
|
|||
|
|
|
|||
|
|
if (pfcb->fFormatted && fn != fnScratch && pn >= pfcb->pnChar)
|
|||
|
|
cbpRead = 1;
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
typePN cbpValid = (pfcb->fcMac - (pn * cfcPage)) / cfcPage;
|
|||
|
|
|
|||
|
|
cbpRead = min( cbpRead, max( 1, cbpValid ) );
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#ifdef ALIGN
|
|||
|
|
/* Align the read request on an even sector boundary, for speed */
|
|||
|
|
dibpAlign = (pn % cpnAlign);
|
|||
|
|
if (cbpRead > dibpAlign)
|
|||
|
|
/* We are reading enough pages to cover the desired one */
|
|||
|
|
pn -= dibpAlign;
|
|||
|
|
else
|
|||
|
|
dibpAlign = 0;
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
/* Remove flushed slots from their hash chains */
|
|||
|
|
for ( pbps = &mpibpbps[ ibpT = ibpNew + cbpRead - 1 ];
|
|||
|
|
ibpT >= ibpNew;
|
|||
|
|
ibpT--, pbps-- )
|
|||
|
|
if (pbps->fn != fnNil)
|
|||
|
|
FreeBufferPage( pbps->fn, pbps->pn );
|
|||
|
|
|
|||
|
|
/* Free slots holding any existing copies of pages to be read */
|
|||
|
|
#ifdef DBCS /* was in KKBUGFIX */
|
|||
|
|
/* In #else code ,If pn= 8000H(= -32768), pnT can not be littler than pn */
|
|||
|
|
for ( pnT = pn + cbpRead; pnT > pn; pnT-- ) // Assume cbpRead > 0
|
|||
|
|
FreeBufferPage( fn, pnT-1 );
|
|||
|
|
#else
|
|||
|
|
for ( pnT = pn + cbpRead - 1; (int)pnT >= (int)pn; pnT-- )
|
|||
|
|
FreeBufferPage( fn, pnT );
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
|
|||
|
|
/* Read contents of file page(s) into buffer slot(s) */
|
|||
|
|
cch = CchPageIn( fn, pn, rgbp[ibpNew], cbpRead );
|
|||
|
|
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
cbpReadT = cbpRead;
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
/* Fill in bps records for as many bytes as were read, but always
|
|||
|
|
at least one record (to support PnAlloc). If we reached the end of the
|
|||
|
|
file, the unfilled bps slots are left free */
|
|||
|
|
pbps = &mpibpbps[ ibpT = ibpNew ];
|
|||
|
|
do
|
|||
|
|
{
|
|||
|
|
pbps->fn = fn;
|
|||
|
|
pbps->pn = pn;
|
|||
|
|
pbps->ts = ++tsMruBps; /* mark page as MRUsed */
|
|||
|
|
pbps->fDirty = false;
|
|||
|
|
pbps->cch = min( cch, cbSector );
|
|||
|
|
pbps->ibpHashNext = ibpNil;
|
|||
|
|
|
|||
|
|
cch = max( cch - cbSector, 0 );
|
|||
|
|
|
|||
|
|
/* put in new hash table entry for fn,pn */
|
|||
|
|
iibpHash = IibpHash(fn, pn);
|
|||
|
|
ibp = rgibpHash[iibpHash];
|
|||
|
|
ibpPrev = ibpNil;
|
|||
|
|
while (ibp != ibpNil)
|
|||
|
|
{
|
|||
|
|
ibpPrev = ibp;
|
|||
|
|
ibp = mpibpbps[ibp].ibpHashNext;
|
|||
|
|
}
|
|||
|
|
if (ibpPrev == ibpNil)
|
|||
|
|
rgibpHash[iibpHash] = ibpT;
|
|||
|
|
else
|
|||
|
|
mpibpbps[ibpPrev].ibpHashNext = ibpT;
|
|||
|
|
|
|||
|
|
pn++; ibpT++; pbps++;
|
|||
|
|
|
|||
|
|
} while ( (--cbpRead > 0) && (cch > 0) );
|
|||
|
|
|
|||
|
|
#ifdef CKSM
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
/* Compute checksums for newly read pages */
|
|||
|
|
|
|||
|
|
{
|
|||
|
|
int ibp;
|
|||
|
|
|
|||
|
|
for ( ibp = ibpNew; ibp < ibpNew + cbpReadT; ibp++ )
|
|||
|
|
if (mpibpbps [ibp].fn != fnNil && !mpibpbps [ibp].fDirty)
|
|||
|
|
(**hpibpcksm) [ibp] = CksmFromIbp( ibp );
|
|||
|
|
}
|
|||
|
|
CheckIbp();
|
|||
|
|
#endif /* DEBUG */
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#ifdef ALIGN
|
|||
|
|
return (ibpNew + dibpAlign);
|
|||
|
|
#else
|
|||
|
|
return (ibpNew);
|
|||
|
|
#endif
|
|||
|
|
} /* end of I b p M a k e V a l i d */
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
FreeBufferPage( fn, pn )
|
|||
|
|
int fn;
|
|||
|
|
int pn;
|
|||
|
|
{ /* Free buffer page holding page pn of file fn if there is one */
|
|||
|
|
/* Flushes fn if page is dirty */
|
|||
|
|
int iibp = IibpHash( fn, pn );
|
|||
|
|
int ibp = rgibpHash[ iibp ];
|
|||
|
|
int ibpPrev = ibpNil;
|
|||
|
|
|
|||
|
|
Assert( fn != fnNil );
|
|||
|
|
while (ibp != ibpNil)
|
|||
|
|
{
|
|||
|
|
struct BPS *pbps=&mpibpbps[ ibp ];
|
|||
|
|
|
|||
|
|
if ( (pbps->fn == fn) && (pbps->pn == pn ) )
|
|||
|
|
{ /* Found it. Remove this page from the chain & mark it free */
|
|||
|
|
|
|||
|
|
if (pbps->fDirty)
|
|||
|
|
FFlushFn( fn );
|
|||
|
|
#ifdef CKSM
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
else /* Page has not been trashed while in memory */
|
|||
|
|
{
|
|||
|
|
Assert( (**hpibpcksm) [ibp] == CksmFromIbp( ibp ) );
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
if (ibpPrev == ibpNil)
|
|||
|
|
/* First entry in hash chain */
|
|||
|
|
rgibpHash [ iibp ] = pbps->ibpHashNext;
|
|||
|
|
else
|
|||
|
|
mpibpbps[ ibpPrev ].ibpHashNext = pbps->ibpHashNext;
|
|||
|
|
|
|||
|
|
pbps->fn = fnNil;
|
|||
|
|
pbps->fDirty = FALSE;
|
|||
|
|
/* Mark the page not recently used */
|
|||
|
|
pbps->ts = tsMruBps - (ibpMax * 4);
|
|||
|
|
/* Mark pages that are on even clump boundaries a bit less recently
|
|||
|
|
used so they are favored in new allocations */
|
|||
|
|
if (ibp % cbpClump == 0)
|
|||
|
|
--(pbps->ts);
|
|||
|
|
pbps->ibpHashNext = ibpNil;
|
|||
|
|
}
|
|||
|
|
ibpPrev = ibp;
|
|||
|
|
ibp = pbps->ibpHashNext;
|
|||
|
|
}
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
CheckIbp();
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
int CchPageIn(fn, pn, rgbBuf, cpnRead)
|
|||
|
|
int fn;
|
|||
|
|
typePN pn;
|
|||
|
|
CHAR rgbBuf[];
|
|||
|
|
int cpnRead;
|
|||
|
|
{ /*
|
|||
|
|
Description: Read a cpnRead pages of file fn from disk into rgbBuf.
|
|||
|
|
Have already determined that page is not resident
|
|||
|
|
in the buffer.
|
|||
|
|
Returns: Number of valid chars read (zero or positive #).
|
|||
|
|
*/
|
|||
|
|
struct FCB *pfcb = &(**hpfnfcb)[fn];
|
|||
|
|
typeFC fcMac = pfcb->fcMac;
|
|||
|
|
typeFC fcPage = pn * cfcPage;
|
|||
|
|
int dfc;
|
|||
|
|
int fCharFormatInfo; /* if reading Format info part of */
|
|||
|
|
/* file then = TRUE, text part of */
|
|||
|
|
/* file then = FALSE; */
|
|||
|
|
|
|||
|
|
/* No reads > 32767 bytes, so dfc can be int */
|
|||
|
|
Assert( cpnRead <= 32767 / cbSector );
|
|||
|
|
|
|||
|
|
/* Don't try to read beyond pnMac */
|
|||
|
|
if (cpnRead > pfcb->pnMac - pn)
|
|||
|
|
cpnRead = pfcb->pnMac - pn;
|
|||
|
|
|
|||
|
|
dfc = cpnRead * (int)cfcPage;
|
|||
|
|
|
|||
|
|
if (pn >= pfcb->pnMac) /* are we trying to read beyond eof? */
|
|||
|
|
{
|
|||
|
|
return 0; /* Nothing to read */
|
|||
|
|
}
|
|||
|
|
else if (pfcb->fFormatted && fn != fnScratch
|
|||
|
|
&& fn != vfnWriting /* Since pnChar is zero in this case */
|
|||
|
|
&& pn >= pfcb->pnChar)
|
|||
|
|
{ /* reading character format info portion of file */
|
|||
|
|
fCharFormatInfo = TRUE;
|
|||
|
|
}
|
|||
|
|
else /* reading text portion of file */
|
|||
|
|
{ /* get dfc (cch) from fcMac */
|
|||
|
|
typeFC dfcT = fcMac - fcPage;
|
|||
|
|
|
|||
|
|
fCharFormatInfo = FALSE;
|
|||
|
|
if (dfcT < dfc)
|
|||
|
|
dfc = (int) dfcT;
|
|||
|
|
else if (dfc <= fc0) /* Nothing to read, so let's avoid disk access. */
|
|||
|
|
{
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return CchReadAtPage( fn, pn, rgbBuf, (int)dfc, fCharFormatInfo );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
CchReadAtPage( fn, pn, rgb, dfc, fSeriousErr )
|
|||
|
|
int fn;
|
|||
|
|
typePN pn;
|
|||
|
|
CHAR rgb[];
|
|||
|
|
int dfc;
|
|||
|
|
int fSeriousErr;
|
|||
|
|
{ /*
|
|||
|
|
Description: Read dfc bytes of file fn starting at page pn
|
|||
|
|
into rgb
|
|||
|
|
Returns: Number of valid chars read (zero or positive #)
|
|||
|
|
Errors: Returns # of chars read; ferror & vfDiskFull are
|
|||
|
|
set (in DiskError) if an error occurs.
|
|||
|
|
Notes: Caller is responsible for assuring that the page
|
|||
|
|
range read is reasonable wrt the fn
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
typeOSFN osfn;
|
|||
|
|
int fpeSeek;
|
|||
|
|
int fpeRead;
|
|||
|
|
int fCaught; /* Whether error was reported by DOS */
|
|||
|
|
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
|
|||
|
|
if (vfFakeReadErr)
|
|||
|
|
{
|
|||
|
|
dfc = 0;
|
|||
|
|
goto ReportErr;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
if (!FIsErrFpe( fpeSeek = FpeSeekFnPn( fn, pn )))
|
|||
|
|
{
|
|||
|
|
osfn = OsfnEnsureValid( fn );
|
|||
|
|
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
#ifdef DFILE
|
|||
|
|
CommSzSz( "Read from file: ", &(**(**hpfnfcb)[fn].hszFile)[0] );
|
|||
|
|
#endif
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
if ((fpeRead = CchReadDoshnd( osfn, (CHAR FAR *)rgb, dfc )) == dfc)
|
|||
|
|
{ /* Read succeeded */
|
|||
|
|
return dfc;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
/* Should be guaranteed that file was not closed because of seek */
|
|||
|
|
Assert( fpeRead != fpeBadHndError );
|
|||
|
|
|
|||
|
|
fCaught = FIsCaughtFpe( fpeRead );
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
fCaught = FIsCaughtFpe( fpeSeek );
|
|||
|
|
|
|||
|
|
/* unable to set position or read */
|
|||
|
|
if ((fn == fnScratch) || (fSeriousErr))
|
|||
|
|
{ /* unrecoverable error: either can't read from scratch */
|
|||
|
|
/* file or unable to read format info (FIB or format pages) part of */
|
|||
|
|
/* of some file. */
|
|||
|
|
dfc = 0;
|
|||
|
|
goto ReportErr;
|
|||
|
|
}
|
|||
|
|
else /* serious disk error on file (recoverable).*/
|
|||
|
|
{
|
|||
|
|
int cchRead = (FIsErrFpe(fpeSeek) || FIsErrFpe(fpeRead)) ? 0 : fpeRead;
|
|||
|
|
CHAR *pch = &rgb[cchRead];
|
|||
|
|
int cch = dfc - cchRead;
|
|||
|
|
|
|||
|
|
/* If the positioning failed or the read failed
|
|||
|
|
for a reason other than disk full, completely
|
|||
|
|
fill the buffer with 'X's. Otherwise, just
|
|||
|
|
fill the disputed portion (diff between #char
|
|||
|
|
requested and #char read) with 'X's */
|
|||
|
|
|
|||
|
|
while (cch-- > 0)
|
|||
|
|
*pch++ = 'X';
|
|||
|
|
|
|||
|
|
ReportErr:
|
|||
|
|
if (fCaught)
|
|||
|
|
/* Suppress reporting of the error -- Windows reported it */
|
|||
|
|
ferror = TRUE;
|
|||
|
|
|
|||
|
|
if (pn != 0)
|
|||
|
|
/* Report error if not reading FIB */
|
|||
|
|
DiskErrorWithMsg(IDPMTSDE, " CchReadAtPage");
|
|||
|
|
|
|||
|
|
return (int)dfc;
|
|||
|
|
/* recovery is accomplished: 1) Upper level procedures do not
|
|||
|
|
see any change in the world, 2) the worst thing that
|
|||
|
|
happens is that the user sees some 'X's on the screen. */
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
AlignFn(fn, cch, fEven)
|
|||
|
|
int fn, cch;
|
|||
|
|
{ /* Make sure we have cch contiguous chars in fn */
|
|||
|
|
/* if fEven, make sure fcMac is even */
|
|||
|
|
struct FCB *pfcb = &(**hpfnfcb)[fn];
|
|||
|
|
typeFC fcMac = pfcb->fcMac;
|
|||
|
|
typePN pn;
|
|||
|
|
typeFC fcFirstPage;
|
|||
|
|
|
|||
|
|
pn = fcMac / cfcPage;
|
|||
|
|
fcFirstPage = (pn + 1) * cfcPage;
|
|||
|
|
|
|||
|
|
Assert(cch <= cfcPage);
|
|||
|
|
|
|||
|
|
if (fEven && (fcMac & 1) != 0)
|
|||
|
|
++cch;
|
|||
|
|
|
|||
|
|
if (fcFirstPage - fcMac < cch)
|
|||
|
|
{
|
|||
|
|
struct BPS *pbps = &mpibpbps[IbpEnsureValid(fn, pn++)];
|
|||
|
|
pbps->cch = cfcPage;
|
|||
|
|
pbps->fDirty = true;
|
|||
|
|
fcMac = pfcb->fcMac = fcFirstPage;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (fEven && (fcMac & 1) != 0)
|
|||
|
|
{
|
|||
|
|
struct BPS *pbps = &mpibpbps[IbpEnsureValid(fn, pn)];
|
|||
|
|
pbps->cch++;
|
|||
|
|
pbps->fDirty = true;
|
|||
|
|
pfcb->fcMac++;
|
|||
|
|
}
|
|||
|
|
} /* end of A l i g n F n */
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
/*** OsfnEnsureValid - ensure that file fn is open
|
|||
|
|
*
|
|||
|
|
*
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
STATIC typeOSFN near OsfnEnsureValid(fn)
|
|||
|
|
int fn;
|
|||
|
|
{ /*
|
|||
|
|
Description: Ensure that file fn is open (really)
|
|||
|
|
Returns: operating system file number (osfnNil if error)
|
|||
|
|
*/
|
|||
|
|
struct FCB *pfcb = &(**hpfnfcb)[fn];
|
|||
|
|
int rfn = pfcb->rfn;
|
|||
|
|
|
|||
|
|
if (rfn == rfnNil)
|
|||
|
|
{ /* file doesn't have a rfn - ie. it is not opened */
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
#ifdef DFILE
|
|||
|
|
CommSzSz( pfcb->fOpened ? "Re-opening file " :
|
|||
|
|
"Opening file", **pfcb->hszFile );
|
|||
|
|
#endif
|
|||
|
|
if (vfFakeOpenErr || !FAccessFn( fn, dtyNormal ))
|
|||
|
|
#else
|
|||
|
|
if (!FAccessFn( fn, dtyNormal ))
|
|||
|
|
#endif
|
|||
|
|
{ /* unrecoverable error - unable to open file */
|
|||
|
|
DiskErrorWithMsg(IDPMTSDE, " OsfnEnsureValid");
|
|||
|
|
return osfnNil;
|
|||
|
|
}
|
|||
|
|
rfn = pfcb->rfn;
|
|||
|
|
Assert( (rfn >= 0) && (rfn < rfnMac) );
|
|||
|
|
}
|
|||
|
|
return dnrfn[rfn].osfn;
|
|||
|
|
}
|
|||
|
|
/* end of O s F n E n s u r e V a l i d */
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
STATIC int near FpeSeekFnPn( fn, pn )
|
|||
|
|
int fn;
|
|||
|
|
typePN pn;
|
|||
|
|
{ /* Seek to page pn of file fn
|
|||
|
|
return err code on failure, fpeNoErr on success
|
|||
|
|
Leaves file open (if no error occurs)
|
|||
|
|
Recovers from the case in which windows closed the file for us
|
|||
|
|
*/
|
|||
|
|
typeOSFN osfn;
|
|||
|
|
long dwSeekReq;
|
|||
|
|
long dwSeekAct;
|
|||
|
|
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
#ifdef DFILE
|
|||
|
|
CommSzSz( "Seeking within file ", **(**hpfnfcb)[fn].hszFile );
|
|||
|
|
#endif
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
//osfn = OsfnEnsureValid( fn );
|
|||
|
|
if ((osfn = OsfnEnsureValid( fn )) == osfnNil)
|
|||
|
|
return fpeNoAccError;
|
|||
|
|
dwSeekReq = (long) pn * (long) cbSector;
|
|||
|
|
dwSeekAct = DwSeekDw( osfn, dwSeekReq, SF_BEGINNING);
|
|||
|
|
|
|||
|
|
if ( ((int) dwSeekAct) == fpeBadHndError )
|
|||
|
|
{ /* Windows closed the file for us -- must reopen it */
|
|||
|
|
if ((osfn = OsfnReopenFn( fn )) == osfnNil)
|
|||
|
|
return fpeNoAccError;
|
|||
|
|
else
|
|||
|
|
dwSeekAct = DwSeekDw( osfn, dwSeekReq, SF_BEGINNING );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return (dwSeekAct >= 0) ? fpeNoErr : (int) dwSeekAct;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
int FFlushFn(fn)
|
|||
|
|
int fn;
|
|||
|
|
{ /*
|
|||
|
|
Description: Write all dirty pages of fn to disk.
|
|||
|
|
Sets vfSysFull = TRUE if disk full error occurred
|
|||
|
|
while flushing fnScratch. Otherwise, a disk full
|
|||
|
|
error causes vfDiskFull = TRUE.
|
|||
|
|
Serious disk errors cause vfDiskError = TRUE
|
|||
|
|
Only the pages which actually made it to disk are
|
|||
|
|
marked as non-dirty.
|
|||
|
|
Returns: TRUE if successful, FALSE if Disk full error
|
|||
|
|
while writing pages to disk. Any other error
|
|||
|
|
is unrecoverable, ie. go back to main loop.
|
|||
|
|
To avoid extraneous error messages, the following
|
|||
|
|
two entry conditions cause FFlush to immediately
|
|||
|
|
return FALSE:
|
|||
|
|
- If vfSysFull = TRUE and fn = fnScratch
|
|||
|
|
- If vfDiskFull = TRUE and fn = vfnWriting
|
|||
|
|
*/
|
|||
|
|
int ibp;
|
|||
|
|
typeOSFN osfn;
|
|||
|
|
int fpe;
|
|||
|
|
int cchWritten;
|
|||
|
|
int cchAskWrite;
|
|||
|
|
struct BPS *pbps;
|
|||
|
|
|
|||
|
|
Assert( fn != fnNil );
|
|||
|
|
|
|||
|
|
if ((vfSysFull) && (fn == fnScratch)) return (FALSE);
|
|||
|
|
if ((vfDiskFull) && (fn == vfnWriting)) return (FALSE);
|
|||
|
|
|
|||
|
|
for (ibp = 0, pbps = mpibpbps; ibp < ibpMax; )
|
|||
|
|
{
|
|||
|
|
if (pbps->fn == fn && pbps->fDirty)
|
|||
|
|
{
|
|||
|
|
typePN pn = pbps->pn;
|
|||
|
|
int cbp = 0;
|
|||
|
|
CHAR *pch = (CHAR *)rgbp[ibp];
|
|||
|
|
struct BPS *pbpsStart = &mpibpbps[ibp];
|
|||
|
|
|
|||
|
|
|
|||
|
|
/* Coalesce all consecutive pages for a single write */
|
|||
|
|
do
|
|||
|
|
{
|
|||
|
|
/* taken out 11/7/84 - can't mark scratch file
|
|||
|
|
page as non dirty if chance that it will never
|
|||
|
|
get written out (write fails - disk full)
|
|||
|
|
pbps->fDirty = false; mark page as clean */
|
|||
|
|
++ibp, ++cbp, ++pbps;
|
|||
|
|
} while (ibp < ibpMax && pbps->fn == fn && pbps->pn == pn + cbp);
|
|||
|
|
|
|||
|
|
/* Now do the write, checking for out of disk space */
|
|||
|
|
Scribble(3, 'W');
|
|||
|
|
|
|||
|
|
cchAskWrite = (int)cbSector * (cbp - 1) + (pbps - 1)->cch;
|
|||
|
|
cchWritten = cchDiskHardError; /* assure hard error if seek fails */
|
|||
|
|
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
if (vfFakeWriteErr)
|
|||
|
|
goto SeriousError;
|
|||
|
|
else
|
|||
|
|
#endif
|
|||
|
|
if ( FIsErrFpe( FpeSeekFnPn( fn, pn )) ||
|
|||
|
|
((osfn = OsfnEnsureValid( fn )) == osfnNil) ||
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
#ifdef DFILE
|
|||
|
|
(CommSzSz( "Writing to file: ", &(**(**hpfnfcb)[fn].hszFile)[0] ),
|
|||
|
|
#endif
|
|||
|
|
#endif
|
|||
|
|
(( cchWritten = CchWriteDoshnd( osfn, (CHAR FAR *)pch,
|
|||
|
|
cchAskWrite )) != cchAskWrite))
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
#ifdef DFILE
|
|||
|
|
)
|
|||
|
|
#endif
|
|||
|
|
#endif
|
|||
|
|
{
|
|||
|
|
/* Should be guaranteed that windows did not close the file
|
|||
|
|
since we have not called intermodule since the seek */
|
|||
|
|
Assert( cchWritten != fpeBadHndError );
|
|||
|
|
|
|||
|
|
/* Seek or Write error */
|
|||
|
|
if ( !FIsErrCchDisk(cchWritten) )
|
|||
|
|
{ /* serious but recoverable disk error */
|
|||
|
|
/* Ran out of disk space; write failed */
|
|||
|
|
if (fn == fnScratch)
|
|||
|
|
vfSysFull = fTrue;
|
|||
|
|
vfDiskFull = fTrue;
|
|||
|
|
DiskErrorWithMsg(IDPMTDFULL, " FFlushFn");
|
|||
|
|
return(FALSE);
|
|||
|
|
}
|
|||
|
|
else /* cause of error is not disk full */
|
|||
|
|
{ /* unrecov. disk error */
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
SeriousError:
|
|||
|
|
#endif
|
|||
|
|
DiskErrorWithMsg(IDPMTSDE2, " FFlushFn");
|
|||
|
|
return FALSE;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
Diag(CommSzNumNum(" cchWritten, cchAskWrite ",cchWritten,cchAskWrite));
|
|||
|
|
|
|||
|
|
/* ---- write was successful ---- */
|
|||
|
|
Scribble(3, ' ');
|
|||
|
|
while (cbp-- > 0)
|
|||
|
|
{ /* mark pages actually copied to disk as non dirty */
|
|||
|
|
(pbpsStart++)->fDirty = false;
|
|||
|
|
#ifdef CKSM
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
{
|
|||
|
|
int ibpT = pbpsStart - 1 - mpibpbps;
|
|||
|
|
/* Recompute checksums for pages which are now clean */
|
|||
|
|
(**hpibpcksm) [ibpT] = CksmFromIbp( ibpT );
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
++ibp;
|
|||
|
|
++pbps;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return (TRUE);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
CheckIbp()
|
|||
|
|
{
|
|||
|
|
/* Walk through the rgibpHash and the mpibpbps structure to make sure all of
|
|||
|
|
the links are right. */
|
|||
|
|
|
|||
|
|
/* 10/11/85 - Added extra Assert ( FALSE ) so we get the messages instead
|
|||
|
|
of a freeze-up on systems not connected to a COM port.
|
|||
|
|
Ignoring the assertion will produce the RIP with the ibp info */
|
|||
|
|
extern int fIbpCheck;
|
|||
|
|
int rgfibp[255];
|
|||
|
|
int ibp;
|
|||
|
|
int ibpHash;
|
|||
|
|
int iibp;
|
|||
|
|
static BOOL bAsserted=FALSE;
|
|||
|
|
|
|||
|
|
if (fIbpCheck && !bAsserted)
|
|||
|
|
{
|
|||
|
|
if (!(ibpMax < 256))
|
|||
|
|
{
|
|||
|
|
Assert(0);
|
|||
|
|
bAsserted=TRUE;
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bltc(rgfibp, false, ibpMax);
|
|||
|
|
|
|||
|
|
/* Are there any circular links in mpibpbps? */
|
|||
|
|
for (iibp = 0; iibp < iibpHashMax; iibp++)
|
|||
|
|
{
|
|||
|
|
if ((ibpHash = rgibpHash[iibp]) != ibpNil)
|
|||
|
|
{
|
|||
|
|
if (!(ibpHash < ibpMax))
|
|||
|
|
{
|
|||
|
|
Assert(0);
|
|||
|
|
bAsserted=TRUE;
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
if (rgfibp[ibpHash])
|
|||
|
|
{
|
|||
|
|
/* Each entry in rgibpHash should point to an unique chain.
|
|||
|
|
*/
|
|||
|
|
Assert(0);
|
|||
|
|
bAsserted=TRUE;
|
|||
|
|
#if DUGSTUB
|
|||
|
|
FatalExit(0x100 | ibp);
|
|||
|
|
#endif
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
rgfibp[ibpHash] = true;
|
|||
|
|
while ((ibpHash = mpibpbps[ibpHash].ibpHashNext) != ibpNil)
|
|||
|
|
{
|
|||
|
|
if (!(ibpHash < ibpMax))
|
|||
|
|
{
|
|||
|
|
Assert(0);
|
|||
|
|
bAsserted=TRUE;
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
if (rgfibp[ibpHash])
|
|||
|
|
{
|
|||
|
|
/* The chain should be non-circular and unique. */
|
|||
|
|
Assert( FALSE );
|
|||
|
|
bAsserted=TRUE;
|
|||
|
|
#if DUGSTUB
|
|||
|
|
FatalExit(0x200 | ibpHash);
|
|||
|
|
#endif
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
rgfibp[ibpHash] = true;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* All chains not pointed to by rgibpHash should be nil. */
|
|||
|
|
for (ibp = 0; ibp < ibpMax; ibp++)
|
|||
|
|
{
|
|||
|
|
if (!rgfibp[ibp])
|
|||
|
|
{
|
|||
|
|
if (mpibpbps[ibp].fn != fnNil)
|
|||
|
|
{
|
|||
|
|
Assert( FALSE );
|
|||
|
|
bAsserted=TRUE;
|
|||
|
|
#if DUGSTUB
|
|||
|
|
FatalExit(0x400 | mpibpbps[ibp].fn);
|
|||
|
|
#endif
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
if (mpibpbps[ibp].ibpHashNext != ibpNil)
|
|||
|
|
{
|
|||
|
|
Assert( FALSE );
|
|||
|
|
bAsserted=TRUE;
|
|||
|
|
#if DUGSTUB
|
|||
|
|
FatalExit(0x300 | ibp);
|
|||
|
|
#endif
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
#endif /* DEBUG */
|
|||
|
|
|
|||
|
|
|
|||
|
|
/* Formerly fileOC.c -- file open and close routines */
|
|||
|
|
|
|||
|
|
|
|||
|
|
/*** SetRfnMac - set usable # of rfn slots
|
|||
|
|
*
|
|||
|
|
* ENTRY: crfn - desired # of rfn slots
|
|||
|
|
* EXIT: (global) rfnMac - set to crfn, if possible
|
|||
|
|
*
|
|||
|
|
* The ability to adjust the usable # of rfn slots is a new addition in
|
|||
|
|
* Windows Word. The two things that it accomplishes are:
|
|||
|
|
*
|
|||
|
|
* (1) Gives the ability for Word to scale back its need for
|
|||
|
|
* DOS file handles if not enough are available
|
|||
|
|
* (2) Permits Word to attempt to grab more file handles than usual
|
|||
|
|
* when this would help performance (in particular, during
|
|||
|
|
* Transfer Save, when the original, scratch, and write files
|
|||
|
|
* are most commonly open)
|
|||
|
|
*
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
SetRfnMac( crfn )
|
|||
|
|
int crfn;
|
|||
|
|
{
|
|||
|
|
int rfn;
|
|||
|
|
|
|||
|
|
Assert( (crfn > 0) && (crfn <= rfnMax) );
|
|||
|
|
Assert( (sizeof (struct ERFN) & 1) == 0); /* ERFN must be even for blt */
|
|||
|
|
|
|||
|
|
if (crfn > rfnMac)
|
|||
|
|
{ /* Add rfn slots */
|
|||
|
|
|
|||
|
|
for ( rfn = rfnMac; rfn < crfn; rfn++ )
|
|||
|
|
dnrfn [rfn].fn = fnNil; /* These will get used next (see RfnGrab)*/
|
|||
|
|
rfnMac = crfn;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
else /* Lose Rfn slots (keep the most recently used one(s)) */
|
|||
|
|
while ( rfnMac > crfn )
|
|||
|
|
{
|
|||
|
|
int rfnLru=RfnGrab();
|
|||
|
|
int fn;
|
|||
|
|
|
|||
|
|
if ( (rfnLru != --rfnMac) && ((fn = dnrfn [rfnMac].fn) != fnNil) )
|
|||
|
|
{
|
|||
|
|
extern int fnMac;
|
|||
|
|
|
|||
|
|
Assert( fn >= 0 && fn < fnMac );
|
|||
|
|
(**hpfnfcb) [fn].rfn = rfnLru;
|
|||
|
|
blt( &dnrfn [rfnMac], &dnrfn [rfnLru],
|
|||
|
|
sizeof(struct ERFN)/sizeof(int) );
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
/*========================================================*/
|
|||
|
|
STATIC int near RfnGrab()
|
|||
|
|
{ /*
|
|||
|
|
Description: Allocate the least recently used rfn (real file #)
|
|||
|
|
slot for a new file.
|
|||
|
|
Returns: rfn slot number. */
|
|||
|
|
|
|||
|
|
int rfn = 0, rfnLru = 0;
|
|||
|
|
typeTS ts, tsLru;
|
|||
|
|
struct ERFN *perfn = &dnrfn[rfn];
|
|||
|
|
|
|||
|
|
/* Time stamp algorithm akin to method used with Bps. */
|
|||
|
|
/* See IbpLru in file.c for comments. */
|
|||
|
|
|
|||
|
|
tsLru = -1; /* max unsigned number */
|
|||
|
|
for ( rfn = 0; rfn < rfnMac ; rfn++, perfn++ )
|
|||
|
|
{
|
|||
|
|
ts = perfn->ts - (tsMruRfn + 1);
|
|||
|
|
if (perfn->fn == fnNil)
|
|||
|
|
ts = ts - rfnMac;
|
|||
|
|
|
|||
|
|
/* cluge: If slot is unused, give it a lower ts. */
|
|||
|
|
/* This ensures that an occupied slot can never be */
|
|||
|
|
/* swapped out if a empty one exists. */
|
|||
|
|
if (ts <= tsLru)
|
|||
|
|
{
|
|||
|
|
tsLru = ts;
|
|||
|
|
rfnLru = rfn;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (dnrfn [rfnLru].fn != fnNil)
|
|||
|
|
CloseRfn( rfnLru );
|
|||
|
|
return rfnLru;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
CloseFn( fn )
|
|||
|
|
int fn;
|
|||
|
|
{ /* Close file fn if it is currently open */
|
|||
|
|
int rfn;
|
|||
|
|
|
|||
|
|
if (fn == fnNil)
|
|||
|
|
return;
|
|||
|
|
|
|||
|
|
if (((rfn = (**hpfnfcb)[fn].rfn) != rfnNil) && (rfn != rfnFree))
|
|||
|
|
CloseRfn( rfn );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
OpenEveryHardFn()
|
|||
|
|
{ /* For each fn representing a file on nonremoveable media,
|
|||
|
|
try to open it. It is not guaranteed that any or all such files
|
|||
|
|
will be open on return from this routine -- we are merely attempting
|
|||
|
|
to assert our ownership of these files on a network by keeping them open */
|
|||
|
|
|
|||
|
|
extern int fnMac;
|
|||
|
|
int fn;
|
|||
|
|
struct FCB *pfcb;
|
|||
|
|
|
|||
|
|
#ifdef DFILE
|
|||
|
|
extern int docCur;
|
|||
|
|
CommSzNum("OpenEveryHardFn: docCur ", docCur);
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
for ( fn = 0, pfcb = &(**hpfnfcb) [0] ; fn < fnMac; fn++, pfcb++ )
|
|||
|
|
{
|
|||
|
|
/* Bryanl 3/26/87: only call FAccessFn if rfn == rfnNil, to prevent
|
|||
|
|
multiple opens of the same file, which fail if the sharer is loaded */
|
|||
|
|
#ifdef DFILE
|
|||
|
|
{
|
|||
|
|
char rgch[100];
|
|||
|
|
if (pfcb->rfn == rfnNil && ((POFSTRUCT)(pfcb->rgbOpenFileBuf))->fFixedDisk)
|
|||
|
|
{
|
|||
|
|
wsprintf(rgch," fn %d, hszFile %s \n\r",fn,(LPSTR)(**pfcb->hszFile));
|
|||
|
|
CommSz(rgch);
|
|||
|
|
wsprintf(rgch," OFSTR %s \n\r", (LPSTR)(((POFSTRUCT)pfcb->rgbOpenFileBuf)->szPathName));
|
|||
|
|
CommSz(rgch);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
wsprintf(rgch," fn %d, not accessing, sz %s\n\r", fn, (LPSTR) (LPSTR)(**pfcb->hszFile));
|
|||
|
|
CommSz(rgch);
|
|||
|
|
wsprintf(rgch," OFSTR %s \n\r", (LPSTR)(((POFSTRUCT)pfcb->rgbOpenFileBuf)->szPathName));
|
|||
|
|
CommSz(rgch);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
if (pfcb->rfn == rfnNil && ((POFSTRUCT)(pfcb->rgbOpenFileBuf))->fFixedDisk)
|
|||
|
|
{ /* fn refers to a file on nonremoveable media */
|
|||
|
|
FAccessFn( fn, dtyNormal );
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
STATIC typeOSFN near OsfnReopenFn( fn )
|
|||
|
|
int fn;
|
|||
|
|
{ /* Reopen file fn after it was automatically closed by Windows due
|
|||
|
|
to disk swap. State is: fn has an rfn but rfn's osfn has been
|
|||
|
|
made a "bad handle" */
|
|||
|
|
|
|||
|
|
struct FCB *pfcb = &(**hpfnfcb) [fn];
|
|||
|
|
int rfn = pfcb->rfn;
|
|||
|
|
typeOSFN osfn;
|
|||
|
|
WORD wOpen;
|
|||
|
|
|
|||
|
|
Assert( fn != fnNil );
|
|||
|
|
Assert( rfn != rfnNil );
|
|||
|
|
Assert( pfcb->fOpened);
|
|||
|
|
|
|||
|
|
/* Only files on floppies are automatically closed */
|
|||
|
|
Assert( ! ((POFSTRUCT)(pfcb->rgbOpenFileBuf))->fFixedDisk );
|
|||
|
|
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
#ifdef DFILE
|
|||
|
|
CommSzSz( "Opening after WINDOWS close: ", **pfcb->hszFile );
|
|||
|
|
#endif
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
wOpen = OF_REOPEN | OF_PROMPT | OF_CANCEL | OF_SHARE_DENY_WRITE |
|
|||
|
|
((pfcb->mdFile == mdBinary) ? OF_READWRITE : OF_READ );
|
|||
|
|
|
|||
|
|
SetErrorMode(1);
|
|||
|
|
osfn = OpenFile( (LPSTR) SzPromptFromFn( fn ),
|
|||
|
|
(LPOFSTRUCT) pfcb->rgbOpenFileBuf, wOpen );
|
|||
|
|
SetErrorMode(0);
|
|||
|
|
|
|||
|
|
if (osfn == -1)
|
|||
|
|
return osfnNil;
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
dnrfn[ rfn ].osfn = osfn;
|
|||
|
|
}
|
|||
|
|
return osfn;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
FAccessFn( fn, dty)
|
|||
|
|
int fn;
|
|||
|
|
int dty;
|
|||
|
|
{ /* Description: Access file which is not currently opened.
|
|||
|
|
Open file and make an appropriate entry in the
|
|||
|
|
rfn table. Put the rfn into (**hpfnfcb)[fn].rfn.
|
|||
|
|
Returns: TRUE on success, FALSE on failure
|
|||
|
|
*/
|
|||
|
|
extern int vwDosVersion;
|
|||
|
|
extern HANDLE hParentWw;
|
|||
|
|
extern HWND vhWndMsgBoxParent;
|
|||
|
|
|
|||
|
|
int rfn;
|
|||
|
|
register struct FCB *pfcb = &(**hpfnfcb)[fn];
|
|||
|
|
typeOSFN osfn;
|
|||
|
|
int wOpen;
|
|||
|
|
|
|||
|
|
#ifdef DEBUG
|
|||
|
|
int junk;
|
|||
|
|
|
|||
|
|
Assert(FValidFile(**pfcb->hszFile, CchSz(**pfcb->hszFile)-1, &junk));
|
|||
|
|
|
|||
|
|
#ifdef DFILE
|
|||
|
|
{
|
|||
|
|
char rgch[100];
|
|||
|
|
|
|||
|
|
CommSzSz("FAccessFn: ", pfcb->fOpened ? SzPromptFromFn( fn ) : &(**pfcb->hszFile)[0]);
|
|||
|
|
wsprintf(rgch, " * OFSTR before %s \n\r", (LPSTR)(((POFSTRUCT)pfcb->rgbOpenFileBuf)->szPathName));
|
|||
|
|
CommSz(rgch);
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
#endif /*DEBUG*/
|
|||
|
|
|
|||
|
|
if ((**pfcb->hszFile)[0] == 0) /* if file name field is blank, */
|
|||
|
|
return FALSE; /* unable to open file */
|
|||
|
|
|
|||
|
|
wOpen = /*OF_PROMPT + OF_CANCEL + (6.21.91) v-dougk bug #6910 */
|
|||
|
|
(((pfcb->mdFile == mdBinary) ?
|
|||
|
|
OF_READWRITE : OF_READ) |
|
|||
|
|
OF_SHARE_DENY_WRITE);
|
|||
|
|
if (pfcb->fOpened)
|
|||
|
|
wOpen += OF_REOPEN;
|
|||
|
|
else if (pfcb->fSearchPath)
|
|||
|
|
wOpen += OF_VERIFY;
|
|||
|
|
|
|||
|
|
if ((vwDosVersion & 0x7F) >= 2)
|
|||
|
|
{
|
|||
|
|
WORD da;
|
|||
|
|
|
|||
|
|
if ((vwDosVersion & 0x7F) >= 3)
|
|||
|
|
/* Above DOS 3, set attributes to deny access if the sharer is in */
|
|||
|
|
wOpen += bSHARE_DENYRDWR;
|
|||
|
|
|
|||
|
|
if ( ( (pfcb->mdFile == mdBinary) && (!pfcb->fOpened)) &&
|
|||
|
|
((da = DaGetFileModeSz( &(**pfcb->hszFile) [0] )) != DA_NIL) &&
|
|||
|
|
(da & DA_READONLY) )
|
|||
|
|
{ /* This is here because the Novell net does not allow us to test
|
|||
|
|
for read-only files by opening in read/write mode -- it lets
|
|||
|
|
us open them anyway! */
|
|||
|
|
goto TryReadOnly;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
for ( ;; )
|
|||
|
|
{
|
|||
|
|
/* OpenFile's first parm is a filename when opening for the
|
|||
|
|
first time, a prompt on successive occasions (OF_REOPEN) */
|
|||
|
|
|
|||
|
|
SetErrorMode(1);
|
|||
|
|
osfn = OpenFile( pfcb->fOpened ?
|
|||
|
|
(LPSTR) SzPromptFromFn( fn ) :
|
|||
|
|
(LPSTR) &(**pfcb->hszFile)[0],
|
|||
|
|
(LPOFSTRUCT) &pfcb->rgbOpenFileBuf[0],
|
|||
|
|
wOpen );
|
|||
|
|
SetErrorMode(0);
|
|||
|
|
|
|||
|
|
if (osfn != -1) /* Note != -1: osfn is unsigned */
|
|||
|
|
{ /* Opened file OK */
|
|||
|
|
#ifdef DFILE
|
|||
|
|
{
|
|||
|
|
char rgch[100];
|
|||
|
|
wsprintf(rgch, " * OFSTR now %s \n\r", (LPSTR)(((POFSTRUCT)(**hpfnfcb) [fn].rgbOpenFileBuf)->szPathName));
|
|||
|
|
CommSz(rgch);
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
if (!pfcb->fOpened)
|
|||
|
|
{ /* First time through: OpenFile may have given us a
|
|||
|
|
different name for the file */
|
|||
|
|
|
|||
|
|
CHAR szT [cchMaxFile];
|
|||
|
|
CHAR (**hsz) [];
|
|||
|
|
|
|||
|
|
#if WINVER >= 0x300
|
|||
|
|
/* Currently: FNormSzFile *TAKES* an OEM sz, and
|
|||
|
|
*RETURNS* an ANSI sz ..pault */
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
if (FNormSzFile( szT, ((POFSTRUCT)pfcb->rgbOpenFileBuf)->szPathName,
|
|||
|
|
dty ) &&
|
|||
|
|
WCompSz( szT, &(**pfcb->hszFile) [0] ) != 0 &&
|
|||
|
|
FnFromSz( szT ) == fnNil &&
|
|||
|
|
!FNoHeap( hsz = HszCreate( szT )))
|
|||
|
|
{
|
|||
|
|
/* Yes, indeed, the name OpenFile gave us was different.
|
|||
|
|
Put the normalized version into the fcb entry */
|
|||
|
|
|
|||
|
|
FreeH( (**hpfnfcb) [fn].hszFile ); /* HEAP MOVEMENT */
|
|||
|
|
(**hpfnfcb) [fn].hszFile = hsz;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
break; /* We succeeded; break out of the loop */
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{ /* Open failed -- try read-only; don't prompt this time */
|
|||
|
|
if ( (pfcb->mdFile == mdBinary) && (!pfcb->fOpened) )
|
|||
|
|
{ /* Failed as read/write; try read-only */
|
|||
|
|
|
|||
|
|
/* Check for sharing violation */
|
|||
|
|
|
|||
|
|
if (((vwDosVersion & 0x7F) >= 3) &&
|
|||
|
|
(((POFSTRUCT) pfcb->rgbOpenFileBuf)->nErrCode == nErrNoAcc))
|
|||
|
|
{
|
|||
|
|
if ( DosxError() == dosxSharing )
|
|||
|
|
{
|
|||
|
|
extern int vfInitializing;
|
|||
|
|
int fT = vfInitializing;
|
|||
|
|
|
|||
|
|
vfInitializing = FALSE; /* Report this err, even during inz */
|
|||
|
|
{
|
|||
|
|
char szMsg[cchMaxSz];
|
|||
|
|
MergeStrings (IDPMTCantShare, **pfcb->hszFile, szMsg);
|
|||
|
|
IdPromptBoxSz(vhWndMsgBoxParent ? vhWndMsgBoxParent : hParentWw, szMsg, MB_OK|MB_ICONEXCLAMATION);
|
|||
|
|
}
|
|||
|
|
vfInitializing = fT;
|
|||
|
|
return FALSE;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
TryReadOnly:
|
|||
|
|
pfcb->mdFile = mdBinRO;
|
|||
|
|
wOpen = OF_READ;
|
|||
|
|
if (pfcb->fOpened)
|
|||
|
|
wOpen += OF_REOPEN;
|
|||
|
|
#ifdef ENABLE
|
|||
|
|
else if (pfcb->fSearchPath)
|
|||
|
|
wOpen += OF_VERIFY;
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
if ((**hpfnfcb)[fn].fDisableRead)
|
|||
|
|
/* already reported */
|
|||
|
|
{
|
|||
|
|
ferror = TRUE;
|
|||
|
|
return FALSE;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{ /* Could not find file in place specified */
|
|||
|
|
char szMsg[cchMaxSz];
|
|||
|
|
extern int ferror;
|
|||
|
|
extern int vfInitializing;
|
|||
|
|
int fT = vfInitializing;
|
|||
|
|
BOOL bRetry=TRUE;
|
|||
|
|
extern struct DOD (**hpdocdod)[];
|
|||
|
|
extern int docCur;
|
|||
|
|
|
|||
|
|
/* get user to put file back */
|
|||
|
|
MergeStrings (IDPMTFileNotFound, **pfcb->hszFile, szMsg);
|
|||
|
|
|
|||
|
|
vfInitializing = FALSE; /* Report this err, even during inz */
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
This is frippin insidious. MessageBox yields and allows us to get
|
|||
|
|
into here again before it has even been issued!
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
(**hpdocdod)[docCur].fDisplayable = FALSE; // block redraws
|
|||
|
|
|
|||
|
|
/* if we're being called from a message box, then use it
|
|||
|
|
as the parent window, otherwise use main write window */
|
|||
|
|
if (IdPromptBoxSz(vhWndMsgBoxParent ? vhWndMsgBoxParent : hParentWw,
|
|||
|
|
szMsg, MB_OKCANCEL | MB_ICONEXCLAMATION | MB_APPLMODAL)
|
|||
|
|
== IDCANCEL)
|
|||
|
|
{
|
|||
|
|
vfInitializing = fT;
|
|||
|
|
(**hpfnfcb)[fn].fDisableRead = TRUE;
|
|||
|
|
ferror = TRUE; /* need to flag */
|
|||
|
|
bRetry = FALSE;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
(**hpdocdod)[docCur].fDisplayable = TRUE; // unblock redraws
|
|||
|
|
|
|||
|
|
vfInitializing = fT;
|
|||
|
|
|
|||
|
|
if (!bRetry)
|
|||
|
|
return FALSE;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
pfcb->fOpened = TRUE;
|
|||
|
|
|
|||
|
|
rfn = RfnGrab();
|
|||
|
|
{
|
|||
|
|
struct ERFN *perfn = &dnrfn [rfn];
|
|||
|
|
|
|||
|
|
perfn->osfn = osfn;
|
|||
|
|
perfn->fn = fn;
|
|||
|
|
perfn->ts = ++tsMruRfn; /* mark Rfn as MRused */
|
|||
|
|
}
|
|||
|
|
(**hpfnfcb) [fn].rfn = rfn;
|
|||
|
|
(**hpfnfcb) [fn].fDisableRead = FALSE;
|
|||
|
|
return TRUE;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
FCreateFile( szFile, fn ) /* returns szFile in ANSI ..pault */
|
|||
|
|
CHAR *szFile;
|
|||
|
|
int fn;
|
|||
|
|
{ /* Create a new, unique file.
|
|||
|
|
Return the name in szFile.
|
|||
|
|
Returns TRUE on success, FALSE on failure.
|
|||
|
|
Leaves the filename in (**hpfnfcb)[fn].hszFile (if successful),
|
|||
|
|
the rfn in (**hpfnfcb)[fn].rfn.
|
|||
|
|
If szFile begins "X:...", creates the file on the specified drive;
|
|||
|
|
otherwise, creates the file on a drive of Windows' choice */
|
|||
|
|
|
|||
|
|
extern CHAR szExtDoc[];
|
|||
|
|
CHAR (**hsz)[];
|
|||
|
|
CHAR szFileT [cchMaxFile];
|
|||
|
|
|
|||
|
|
if (!GetTempFileName(szFile[0] | ((szFile[1] == ':') ? TF_FORCEDRIVE : 0),
|
|||
|
|
(LPSTR)(szExtDoc+1), 0, (LPSTR)szFileT) )
|
|||
|
|
{ /* can't create file */
|
|||
|
|
DiskErrorWithMsg( IDPMTSDE, " RfnCreate" );
|
|||
|
|
|
|||
|
|
/* recovery is accomplished: only FnCreateSz calls FCreateFile.
|
|||
|
|
FnCreateSz returns nil if FCreateFile returns FALSE. All of
|
|||
|
|
FnCreateSz's callers check for nil */
|
|||
|
|
return FALSE;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* Succeeded in creating file */
|
|||
|
|
|
|||
|
|
FNormSzFile( szFile, szFileT, dtyNormal );
|
|||
|
|
|
|||
|
|
if ( FNoHeap( hsz = HszCreate( (PCH)szFile )))
|
|||
|
|
return FALSE;
|
|||
|
|
|
|||
|
|
(**hpfnfcb) [fn].hszFile = hsz;
|
|||
|
|
|
|||
|
|
if ( !FAccessFn( fn, dtyNormal ) )
|
|||
|
|
return FALSE;
|
|||
|
|
|
|||
|
|
return TRUE;
|
|||
|
|
} /* end of F C r e a t e F i l e */
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
FEnsureOnLineFn( fn )
|
|||
|
|
int fn;
|
|||
|
|
{ /* Ensure that file fn is on line (i.e. on a disk that is accessible).
|
|||
|
|
Return TRUE if we were able to guarantee this, FALSE if not */
|
|||
|
|
int rfn;
|
|||
|
|
|
|||
|
|
Assert( fn != fnNil );
|
|||
|
|
|
|||
|
|
if ( ((POFSTRUCT)(**hpfnfcb) [fn].rgbOpenFileBuf)->fFixedDisk )
|
|||
|
|
/* If it's on nonremovable media, we know it's on line */
|
|||
|
|
return TRUE;
|
|||
|
|
|
|||
|
|
/* If it's open, must close and re-open, cause windows might have closed it */
|
|||
|
|
if ((rfn = (**hpfnfcb) [fn].rfn) != rfnNil)
|
|||
|
|
CloseRfn( rfn );
|
|||
|
|
|
|||
|
|
return FAccessFn( fn, dtyNormal );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
typePN PnAlloc(fn)
|
|||
|
|
int fn;
|
|||
|
|
{ /* Allocate the next page of file fn */
|
|||
|
|
typePN pn;
|
|||
|
|
struct BPS *pbps;
|
|||
|
|
struct FCB *pfcb = &(**hpfnfcb)[fn];
|
|||
|
|
|
|||
|
|
AlignFn(fn, (int)cfcPage, false);
|
|||
|
|
pn = pfcb->fcMac / cfcPage;
|
|||
|
|
pbps = &mpibpbps[IbpEnsureValid(fn, pn)];
|
|||
|
|
pbps->cch = cfcPage;
|
|||
|
|
pbps->fDirty = true;
|
|||
|
|
pfcb->fcMac += cfcPage;
|
|||
|
|
pfcb->pnMac = pn + 1;
|
|||
|
|
return pn;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
STATIC CHAR *(near SzPromptFromFn( fn ))
|
|||
|
|
int fn;
|
|||
|
|
{
|
|||
|
|
extern int vfnSaving;
|
|||
|
|
CHAR *pch;
|
|||
|
|
|
|||
|
|
Assert( fn != fnNil );
|
|||
|
|
|
|||
|
|
if (fn == vfnSaving)
|
|||
|
|
pch = szSaveFilePrompt;
|
|||
|
|
else if (fn == fnScratch)
|
|||
|
|
pch = szScratchFilePrompt;
|
|||
|
|
else
|
|||
|
|
pch = szWriteDocPrompt;
|
|||
|
|
|
|||
|
|
return pch;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|