path: root/private/mvdm/wow16/write/trans2.c

/************************************************************/
/* Windows Write, Copyright 1985-1992 Microsoft Corporation */
/************************************************************/

/* trans2.c -- Save routines for WRITE (also see trans4.c; routines were
   moved because of compiler heap overflows) */

#define NOWINMESSAGES
#define NOVIRTUALKEYCODES
#define NOWINSTYLES
#define NOCLIPBOARD
#define NOGDICAPMASKS
#define NOSYSMETRICS
#define NOMENUS
#define NOKEYSTATE
#define NOSYSCOMMANDS
#define NORASTEROPS
#define NOSHOWWINDOW
//#define NOATOM
#define NOCREATESTRUCT
#define NODRAWTEXT
//#define NOGDI
//#define NOMETAFILE
#define NOBRUSH
#define NOPEN
#define NOFONT
#define NOWNDCLASS
#define NOWH
#define NOWINOFFSETS
#define NOICON
#define NOCOMM
#define NOSOUND
#include <windows.h>

#include "mw.h"
#include "doslib.h"
#include "propdefs.h"
#define NOUAC
#include "cmddefs.h"
#include "docdefs.h"
#include "filedefs.h"
#include "fkpdefs.h"
#include "printdef.h"
#include "code.h"
#include "heapdefs.h"
#include "heapdata.h"
#define NOSTRUNDO
#include "str.h"
#include "debug.h"
#include "fontdefs.h"
#include "obj.h"
#include "winddefs.h"

CHAR    *PchGetPn();
CHAR    *PchFromFc();
typePN  PnAlloc();
struct  PGTB **HpgtbGet();

#ifdef DEBUG
    /* Make these variables during debug so testers can force limits */
typeFC          fcBound = (pnMaxScratch >> 2) * ((typeFC)cbSector);
int             cpBound = 512;
#else
#define fcBound     ((typeFC) ((pnMaxScratch >> 2) * ((typeFC)cbSector)))
#define cpBound     (512)
#endif

extern  CHAR *PchFillPchId();

extern int             vfOldWriteFmt;  /* delete objects before saving */
extern HANDLE  hParentWw;
extern int             vfnWriting;
extern struct BPS      *mpibpbps;
extern typeTS          tsMruBps;
extern int             vibpWriting;
extern CHAR            (**vhrgbSave)[];
extern struct DOD      (**hpdocdod)[];
extern int             docCur;
extern int             docMac;
extern int             docScrap;
extern int             docUndo;
extern struct FCB      (**hpfnfcb)[];
extern int             fnMac;
extern int             wwMac;
/* extern ENV             vEnvMainLoop; */
extern int             vfBuffersDirty;
extern int             vfDiskFull;
extern int             vfDiskError;
extern typeCP          vcpFetch;
extern CHAR            *vpchFetch;
extern int             vccpFetch;
extern typeFC          fcMacPapIns;
extern typeFC          fcMacChpIns;
extern typeCP          vcpLimParaCache;
extern struct FKPD     vfkpdCharIns;
extern struct FKPD     vfkpdParaIns;
extern struct PAP      vpapPrevIns;
extern struct PAP      vpapAbs;
extern struct PAP      *vppapNormal;
extern struct CHP      vchpNormal;
extern struct CHP      vchpInsert;
extern struct CHP      vchpFetch;
extern struct FPRM     fprmCache;
extern HCURSOR vhcIBeam;

extern int              ferror;
extern CHAR             szExtBackup[];  /* extension for Write backup files */
extern CHAR             szExtWordBak[];  /* extension for Word backup files */
extern CHAR             (**hszTemp)[];
extern CHAR             szExtDoc[];


#ifdef INTL /* International version */

extern int vfTextOnlySave;
extern int  vWordFmtMode; /* used during saves. If false, no conversion is
                              done. True is convert to Word format,CVTFROMWORD
                              is translate chars from Word character set at
                              save */
#endif  /* International version */




/***         CmdXfSave - Save document to passed filename (TRANSFER SAVE)
 *
 *      ENTRY:  szFile - a normalized filename
 *              fFormatted - TRUE  = save as formatted file
 *                           FALSE = save as unformatted file
 *              fBackup    - TRUE = keep a backup copy of the file
 *                           FALSE = don't (but see below)
 *
 *      EXIT:
 *
 *      NOTE: A backup file may be kept even if fBackup is FALSE.
 *            This is because piece tables in documents other than docCur
 *            may refer to the information.  If a backup file is kept for
 *            this reason, the following holds: (1) The file has an fn,
 *            (2) the file's hpfnfcb entry has its fDelete field set to TRUE,
 *            indicating that the file should be deleted when WORD exits,
 *            (3) the file is, in fact, referenced in some document
 *            (PurgeTemps assures that unreferenced files are deleted)
 *
 *      Note 2: Non-formatted save code modified (bz 12/2/85) to allow
 *            similar saving in Word format. The calls to FnCreate and
 *            FWriteFn were changed to allow for formatted saving, but
 *            FWriteFn is changed to convert text from ANSI to OEM character
 *            sets, to not put out the font table and to mark
 *            the file header (fib) so the file will be treated as a Word
 *            file, but, like a non-formatted save, the piece table is not
 *            cleaned up. Note that the backup file is saved  in the original,
 *            Write format.
 *
 */

CmdXfSave(szFile, fFormatted, fBackup, hcAfterward)
CHAR szFile[];
int fFormatted;
int fBackup;
HCURSOR hcAfterward;    /* handle to cursor to display after hourglass */
{
 extern int vfnSaving;   /* Set this so we prompt for "Write Save File"
                            if disk change is necessary */
 extern int vfDiskError;
 extern int vfSysFull;
 extern int vfOutOfMemory;

 int     fSave = vfDiskError;
 int     fDidBackup;
 CHAR    szFileT [cchMaxFile];
 int     fOutOfMemory=vfOutOfMemory;
 int     docTemp;

 /* Make a local copy of string parm in case it is in the heap */

#ifdef DFILE
 CommSzSz("CmdXfSave----szFile (presumed ANSI) ", szFile);
#endif
 StartLongOp();
 bltsz( szFile, szFileT );
 szFileT[ cchMaxFile - 1] = '\0';

 /* Reset error conditions to give us a chance */

 vfOutOfMemory = vfDiskFull = vfSysFull = vfDiskError = ferror = FALSE;

 SetRfnMac( rfnMacSave );    /* Increase # of DOS handles used to speed save */

 /* Memory kludge: To assure that we can actually save this file under low
        memory conditions, free the bogus heap block */
 if (vhrgbSave != 0)
    {
    FreeH(vhrgbSave);        /* Return this memory to free pool. */
    vhrgbSave = 0;
    }
 /* In-Line version of FreeBitmapCache (so we don't have to swap in
   picture.c) */

 /*FreeBitmapCache(); */              /* Give us even more memory */

 {
 extern int vdocBitmapCache;
 extern HBITMAP vhbmBitmapCache;

 vdocBitmapCache = docNil;
 if (vhbmBitmapCache != NULL)
    {
    DeleteObject( vhbmBitmapCache );
    vhbmBitmapCache = NULL;
    }
 }


 /* Can't undo save -- set "Can't Undo"; also clear out docUndo
    for heap space reclamation and to aid PurgeTemps */

 ClobberDoc(docUndo, docNil, cp0, cp0);
 NoUndo();

 (**hpdocdod)[docCur].fBackup = fBackup;

 /*      Note: Non-formatted save code modified (bz 12/2/85) to allow
 *            similar saving in Word format. The calls to FnCreate and
 *            FWriteFn were changed to allow for formatted saving, but
 *            FWriteFn is changed to convert text from ANSI to OEM character
 *            sets, to not put out the font table and to mark
 *            the file header (fib) so the file will be treated as a Word
 *            file, but, like a non-formatted save, the piece table is not
 *            cleaned up. Note that the backup file is saved  in the original,
 *            Write format.
 *            Note that a file CAN be saved both unformatted and in Word format
 *            - in that case, Word format means convert to OEM character set.
 */

#if defined(OLE)
    ObjSavingDoc(fFormatted);
#endif

 if (((**hpdocdod)[docCur].fFormatted && !fFormatted)
#ifdef INTL /* International version */
      || (vWordFmtMode == TRUE) /* convert To Word format? */
#endif  /* International version */
      || (vfOldWriteFmt))
    { 

    int fn;
    CHAR (**hsz)[];
    CHAR szT [cchMaxFile];
    CHAR szWriteFile [cchMaxFile];
    CHAR szBak [cchMaxFile];

        /* Set szFileT's path name into szWriteFile, so the temp file
           gets created in the right place when we call FnCreateSz */
    SplitSzFilename( szFileT, szWriteFile, szT );

        /* Create szWrite: a new, uniquely named file */
     if ((fn=FnCreateSz( szWriteFile,
                     fFormatted?(**hpdocdod)[docCur].cpMac:cpNil,
                     dtyNetwork ))==fnNil)
            /* Couldn't create the write file */
        goto SaveDone;
    /* Make backup of szFileT (if it exists); purge all unneeded backups
       which were kept for their pieces but are no longer referenced */
    fDidBackup = FBackupSzFile( szFileT, fBackup, szBak );
    if (ferror)
        goto LXFRet;     /* Backup failed */

    PurgeTemps();

    vfnSaving = fn;

    /* ForcePmt(IDPMTSaving);*/

#ifdef INTL /* International version */

    if ((vWordFmtMode == TRUE)  /* converting To Word format? */
     || (vfTextOnlySave == TRUE)  /* converting To Text format? */
     || (vfOldWriteFmt))
    /* Delete all pictures. To do this, make a copy
      of docCur in docTemp, the go through docTemp, deleting all picture
      paragraphs. Write out this document, then kill it. */
    {
    extern typeCP vcpLimParaCache, vcpFirstParaCache;
    extern typeCP cpMinCur, cpMacCur, cpMinDocument;
    typeCP cpMinCurT = cpMinCur;
    typeCP cpMacCurT = cpMacCur;
    typeCP cpMinDocumentT = cpMinDocument;
    typeCP cpNow;
    typeCP cpLimPara, dcp;
    typeCP cpMac = (**hpdocdod) [docCur].cpMac;

    /* Create copy of document */
    docTemp = DocCreate(fnNil, HszCreate(""), dtyNormal);
    if (docTemp == docNil)
        goto SaveDone; /* Out of memory */
    ClobberDoc(docTemp, docCur, cp0, CpMacText(docCur));
    if (ferror)
        return TRUE;

    /* Expand range of interest to whole document (for CachePara) */

    cpMinCur = cp0;
    cpMacCur = cpMac;

    /* Loop on paras */

    for ( cpNow = cp0; cpNow < cpMac; cpNow = cpLimPara )
        {
        CachePara( docTemp, cpNow );
        if (!vpapAbs.fGraphics)
            /* update to next cplim only if not deleting. If deleting,
                next time will be at same cp */
            {
            cpLimPara = vcpLimParaCache;
            continue;
            }

        /* Now delete graphics paragraph */
        Replace(docTemp, vcpFirstParaCache,
                dcp = (vcpLimParaCache - vcpFirstParaCache),
                fnNil, fc0, fc0);
        cpMac -= dcp;  /* size of doc has been reduced */
        }

    /* Restore cpMinCur, cpMacCur */

    cpMinCur = cpMinCurT;
    cpMacCur = cpMacCurT;
                                    /* destroyed possibly by DocCreate */
    cpMinDocument = cpMinDocumentT;
    vcObjects = 0; // OLE object count
    }
    else
#endif  /* International version */

        {
            docTemp = docCur; // note the else, above #endif (2.7.91) D. Kent
        }

    if (FWriteFn(fn, docTemp, fFormatted))
        {
        int fpe = FpeRenameFile( szWriteFile, szFileT );

        if ( FIsErrFpe( fpe ) )
            {   /* Rename failed -- might be nonexistent path */
            Error( (fpe == fpeBadPathError) ? IDPMTNoPath : IDPMTSDE2 );
            }
        else
            OutSaved(docTemp);

        }
    else
        {       /* Write failed */
        if (fDidBackup && !FIsErrFpe(FpeRenameFile(szBak, szFileT)))
            {
            int fn = FnFromSz(szFileT);
            struct FCB      *pfcb;
            if (fn != fnNil)
                {
                (pfcb = &(**hpfnfcb)[fn])->fDelete = false;
                }
            }
        FDeleteFn( fn );
        }


#ifdef INTL /* International version */
    if (vWordFmtMode == TRUE)  /* converting To Word format? */
        KillDoc (docTemp);
#endif  /* International version */


    (**hpdocdod)[docCur].fDirty = false;  /* document should not
                                                 be dirty after T-S.*/
    FreeH((**hpdocdod)[docCur].hszFile);
    hsz = HszCreate((PCH)szFileT);
    (**hpdocdod)[docCur].hszFile = hsz;
    }
else
    {   /* Save Formatted document */
    CleanDoc( docCur, (**hpdocdod)[docCur].dty, szFileT, fFormatted, fBackup );
    }

 OpenEveryHardFn(); /* Reopen files on nonremoveable media so other net
                       users can't steal them away */

SaveDone:

 SetRfnMac( rfnMacEdit );      /* Reduce # of file handles used */
 vfnSaving = fnNil;

#ifdef NEVER
 /* It doesn't do us much good to Assert here that an error didn't happen.
    After-the-fact checking doesn't make up for ignoring real-time errors.
    ..pault 10/31/89 */

 Assert( !vfOutOfMemory );      /* Our reserved space block was sufficient
                                   to get us through the save */
#endif
 vfOutOfMemory = fOutOfMemory;

/* vhrgbSave is a pointer a clump on the heap used during the save operation.
   By freeing it in the beginning of the save operation, we are assured
   that we will have enough memory to actually do the save.
   At the present point
   in the code, we are finished with the save and wish to reclaim vhrgbSave
   so the next Save operation may perform properly.  The net memory usage
   caused by a save should be minimal.  It only temporarily requires a
   significant chunk of memory. */
 vhrgbSave = (CHAR (**)[]) HAllocate( cwSaveAlloc +
                                     ( (wwMac-1) * cwHeapMinPerWindow ));

/* Restore previous disk err state */

#if WINVER >= 0x300
 /* We currently have no way to FORGET they had a disk error.
    So if this whole operation did not have an error and we 
    felt there was one beforehand, we do it now ..pault */
 vfDiskError = (!vfDiskError && fSave) ? fFalse : fSave;
#else
 vfDiskError = fSave;   
#endif

LXFRet:
 EndLongOp(hcAfterward);
}




CleanDoc(doc, dty, szFile, fFormatted, fBackup )
int doc, fFormatted;
int dty;
CHAR szFile[];
int     fBackup;
{ /* Write the contents of doc into szFile and clean up piece table */
  /* if dty == dtyNetwork, writes the doc to a unique file & returns the */
  /* filename through szFile */
  /* Returns the fn of the file it wrote to */

/* *************************************
  In the normal backup processing, we rename the existing file. When
  saving in CONVFROMWORD mode, we want to keep the original Word file around,
  so we bypass the backup phase and then skip the renaming phase below.
  This leaves the original file around. At save time we may write over it
  or rename the saving file, as we wish, but this way we have the Word file
  around in case we don't save out of Write.
************************************** */

extern int vdocParaCache;
extern int vfnSaving;   /* Set this so we prompt for "Save" disk if disk
                           changes are necessary */
int fDidBackup=FALSE;
int fn;
CHAR (**hsz)[];

CHAR szBak [cchMaxFile];
CHAR szWrite [cchMaxFile];
int fDummy;

#if WINVER >= 0x300
/* I don't understand WHY the following resets to ROOT directory, but 
   changing it causes problems -- so I'm leaving it!  Obviously code 
   somewhere else expects file to be there and I don't see it ..pault */
#endif
    /* Set path name of szFile into szWrite so the temp file gets created
       in the right place */
 if (dty == dtyNetwork)
    {
    szWrite [0] = '\0'; /* Create temp file on Temp drive in the root */
    }
 else
    {
    CHAR szT [cchMaxFile];

    SplitSzFilename( szFile, szWrite, szT );
    }

    /* Create szWrite: a new, uniquely named file */
 if ((fn=FnCreateSz( szWrite, fFormatted ? (**hpdocdod)[doc].cpMac : cpNil,
                     dtyNetwork )) == fnNil)
        /* Couldn't create the write file */
    return fnNil;

 vfnSaving = fn;

/* *************************************
  In the normal backup processing, we rename the existing file. When
  saving in CONVFROMWORD mode, we want to keep the original Word file around,
  so we bypass the backup phase and then skip the renaming phase below.
  This leaves the original file around. At save time we may write over it
  or rename the saving file, as we wish, but this way we have the Word file
  around in case we don't save out of Write.
************************************** */

 if (doc != docScrap)
    {
    /* Make a backup of szFile (if szFile exists) */

#ifdef INTL /* International version */
    if (vWordFmtMode == CONVFROMWORD) /* converting from a Word document */
        fDidBackup = false;
    else
#endif  /* International version */
        {
        fDidBackup = FBackupSzFile( szFile, fBackup, szBak );
        if (ferror)
            return;     /* Backup failed */
        }

    PurgeTemps();

    }

 if ( dty == dtyNetwork )
    bltsz( szWrite, szFile );

 if (!FWriteFn(fn, doc, fFormatted))
        {   /* Save failed; rename backup file back to original */
            /* note in intl CONVFROMWORD case, fDidBackup will be false
               and this renaming won't happen, which is ok */
        if (fDidBackup && !FIsErrFpe(FpeRenameFile(szBak, szFile)))
                {
                int fn = FnFromSz(szFile);
                struct FCB      *pfcb;
                if (fn != fnNil)
                        {
                        (pfcb = &(**hpfnfcb)[fn])->fDelete = false;
                        }
                }
        FDeleteFn( fn );
        return fnNil;         /* Disk full or write error */
        }

/* *************************************
  Here we rename our temp file szWrite to have the name of the "save as"
  file. In FBackupSzFile, the fdelete flag for the fn of szfile was set
  on so we don't have to explicitly delete the original file.

  When a CONVFROMWORD save is done, we do not rename and did not go
  through the backup procedure, so the original Word file is still
  out there with its original name. We do, however, set the delete bit to
  true, so the file will get deleted after the next save, when a true rename
  will be done.
************************************** */

 if ( dty != dtyNetwork )

#ifdef INTL /* International version */
    if (vWordFmtMode == CONVFROMWORD) /* converting from a Word document */
        {
        (**hpfnfcb)[fn].fDelete = true;
        }
    else
#endif  /* International version */

        {
        int fpe=FpeRenameFile( szWrite, szFile );

        if (FIsErrFpe( fpe ))
            {
            Error( (fpe == fpeBadPathError) ? IDPMTNoPath : IDPMTSDE2 );
            return fnNil;
            }
        }

if (doc == docScrap)
    (**hpfnfcb)[fn].fDelete = true;
else
    OutSaved(doc);

FreeH((**hpdocdod)[doc].hpctb); /* Free old piece table */
FInitPctb(doc, fn);
(**hpdocdod)[doc].fFormatted = fFormatted;
FreeH((**hpdocdod)[doc].hszFile);
hsz = HszCreate((PCH)szFile);
(**hpdocdod)[doc].hszFile = hsz;

if (fFormatted)
    {
    /* reload font table, which may have changed */

    SmashDocFce(doc);
    FreeFfntb(HffntbGet(doc));
    (**hpdocdod)[doc].hffntb = HffntbCreateForFn(fn, &fDummy);
    //SaveFontProfile(doc);
    ResetDefaultFonts(FALSE);
    }

 /* By diddling the document attributes on save, we have invalidated caches */

 InvalidateCaches( doc );
 vdocParaCache = docNil;

 if (!ferror && !vfBuffersDirty && doc != docScrap)
        ReduceFnScratchFn( fn );

 if (fFormatted)
    {  /* Readjust the running head margins.  We munged them back to the
       paper-relative measurements in FWriteFn, so we'll remunge them
       to margin-relative here. */

 /* With the test for doc != docScrap we fix a major bug, and knowingly at the
    last minute introduce a minor one. The old problem was that we would apply
    a sprm to docScrap, then mash the scratch file in ReduceFnScratch, our
    caller, rendering the bfprm bogus, causing rare crashes.  The new problem
    will be that running head text in the scrap will have incorrect margins
    after a save. */

   if (doc != docScrap)
        ApplyRHMarginSprm( doc );
    InvalidateCaches( doc );
    vdocParaCache = docNil;
    }

 return fn;
}





/***        FWriteFn - write a file
 *
 *      Note: Modified (bz 12/2/85) to allow saving in Word format.
 *            FWriteFn is changed to convert text from ANSI to OEM character
 *            sets, to not put out the font table and to mark
 *            the file header (fib) so the file will be treated as a Word
 *            file.
 *
 */

int FWriteFn(fn, doc, fFormatted)
int fn, doc, fFormatted;
{ /* Write characters from a doc to fn */
/* Return true if successful */
#ifdef CASHMERE
extern int docBuffer;
#endif

typeCP cpMac;
CHAR    *pchFprop;
struct RUN *prun;
struct FIB *pfib;
struct FCB *pfcb;
int     cchT;
struct FNTB **hfntb;
struct FFNTB **hffntb=(struct FFNTB **)NULL;

#ifdef CASHMERE
struct SETB **hsetb = 0, **hsetbT;
#else
struct SEP **hsep;
#endif

struct PGTB **hpgtb;
int ised, csed;
struct SED *psed, *psedT;
int cw;
int fFileFlushed;
int rfn;
CHAR mpftcftc[iffnMax];

struct PAP pap;
struct CHP chp;
struct FKP fkp;

vfnWriting = fn;
vibpWriting = IbpEnsureValid(fn, (typePN)0);

cpMac = (**hpdocdod)[doc].cpMac;

/* FIB has already been written. */
if (fFormatted)
        {

/* KLUDGE: If the doc does not contain at least one complete para,
                   and it has a nonnull tab table,
                   add an Eol to its end to hold the tabs in a FPAP */

        CachePara( doc, cp0 );
        if (vcpLimParaCache > cpMac && (doc != docScrap) &&
            (**hpdocdod) [doc].hgtbd != NULL )
            {
            extern int vdocParaCache;

            InsertEolInsert( doc, cpMac );
            vdocParaCache = docNil;
            cpMac = (**hpdocdod) [doc].cpMac;
            }

                /* Write characters */
                /* Modified to handle ANSI to OEM conversion for Word docs */
        FetchCp(doc, cp0, 0, fcmChars + fcmNoExpand);

                {
                Scribble(4, 'T');

                while (vcpFetch < cpMac && !(vfDiskFull || vfDiskError))
                                        {
#ifdef INTL /* International version */

                if (vWordFmtMode == FALSE) /* no conversion */
#endif  /* International version */

                    WriteRgch(fn, vpchFetch, (int)vccpFetch);

#ifdef INTL /* International version */
                else
                   {
                         /* bufT is a buffer for translating from ANSI to
                         OEM chars.  The amount of data from FetchCp
                         must be no > than a disk page, which is
                         cfcFetch, which is itself cbSector. We use
                         bufT to hold the translated chars, then write
                         them out with WriteRgch. */

                    CHAR bufT[cbSector + 1];
                    CHAR *pch;

                    Assert ((int)vccpFetch <= cbSector);
                      /* load chars into bufT and translate to OEM
                         chars, and write out */
                    pch = (CHAR *) bltbyte(vpchFetch, bufT,
                                           (int)vccpFetch);
                    *pch = '\0';
                    if (vWordFmtMode == TRUE)
                     /* from Write/ANSI to Word/OEM */
                        AnsiToOem((LPSTR)bufT, (LPSTR)bufT);
                    else
                         /* from Word/OEM to Write/ANSI */
                        OemToAnsi((LPSTR)bufT, (LPSTR)bufT);
                    WriteRgch(fn, bufT, (int)vccpFetch);
                   }
#endif  /* International version */


                FetchCp(docNil, cpNil, 0, fcmChars + fcmNoExpand);
                                        }
                Scribble(4,' ');
                }

        if ((vfDiskFull || vfDiskError))
                goto AbortWrite;

        /* Go to beginning of next page */
        AlignFn(fn, cbSector, false);
        (**hpfnfcb)[fn].pnChar = (**hpfnfcb)[fn].pnMac;

        /* Now write char props */
        Scribble(4, 'C');
        fkp.fcFirst = cfcPage; /* first fkp starts with first valid fc */
        fkp.crun = 0;
        prun = (struct RUN *) fkp.rgb;
        pchFprop = &fkp.rgb[cbFkp];
        CachePara(doc, cp0);

        /* set up font mapping and new font table */
        if (!FInitMapSave(doc, &hffntb, mpftcftc))
                goto AbortWrite;

        FetchCp(doc, cp0, 0, fcmProps);
        if (!FMapFtcSave(doc, hffntb, &vchpFetch, mpftcftc))
                goto AbortWrite;

        blt(&vchpFetch, &chp, cwCHP);

        while (vcpFetch < cpMac && !(vfDiskFull || vfDiskError))
                { /* This could be optimized by allowing multiple runs to point */
                    /* to one fchp. */
                
                if (CchDiffer(&vchpFetch, &chp, cchCHP) != 0)
                        {
                        FAddRun(fn, &fkp, &pchFprop, &prun, &chp,
                            &vchpNormal, cchCHP, vcpFetch + cfcPage);
                        blt(&vchpFetch, &chp, cwCHP);
                        }
                FetchCp(docNil, cpNil, 0, fcmProps);
                if (!FMapFtcSave(doc, hffntb, &vchpFetch, mpftcftc))
                        goto AbortWrite;
                }
        Scribble(4,' ');

        if ((vfDiskFull || vfDiskError))
                goto AbortWrite;

        /* Write out last char run. */
        FAddRun(fn, &fkp, &pchFprop, &prun, &chp, &vchpNormal,
            cchCHP, cpMac + cfcPage);
        WriteRgch(fn, &fkp, cbSector);

        if ((vfDiskFull || vfDiskError))
                goto AbortWrite;

        /* Now write para runs; one for every para */
        Scribble(4,'C');
        (**hpfnfcb)[fn].pnPara = (**hpfnfcb)[fn].pnMac;
        fkp.fcFirst = cfcPage; /* first fkp starts with first valid fc */
        fkp.crun = 0;
        prun = (struct RUN *) fkp.rgb;
        pchFprop = &fkp.rgb[cbFkp];
        CachePara(doc, cp0);

        /* KLUDGE: We have running head indents relative to the
                   margins -- subtract out the margins now, because
                   our (WORD-compatible) file format is PAPER-relative */

        if (vpapAbs.rhc)
            {
            struct SEP *psep = *(**hpdocdod)[ doc ].hsep;

            vpapAbs.dxaLeft += psep->xaLeft;
            vpapAbs.dxaRight += psep->xaMac -
                                        (psep->xaLeft + psep->dxaText);
            }

#ifdef INTL
        /* Ensure no pictures in Word documents. This is necessary
           because Word 4.0 uses the fGraphics bit as part of the
           new border type code (btc) property. */
		if (vWordFmtMode == CONVFROMWORD)
            vpapAbs.fGraphics = FALSE;
#endif
        FAddRun(fn, &fkp, &pchFprop, &prun, &vpapAbs, vppapNormal,
            cchPAP, vcpLimParaCache + cfcPage);
        blt(&vpapAbs, &pap, cwPAP);

        while (vcpLimParaCache <= cpMac && !(vfDiskFull || vfDiskError))
                {
                CachePara(doc, vcpLimParaCache);

                /* KLUDGE: We have running head indents relative to the
                   margins -- subtract out the margins now, because
                   our (WORD-compatible) file format is PAPER-relative */

                if (vpapAbs.rhc)
                    {
                    struct SEP *psep = *(**hpdocdod)[ doc ].hsep;

                    vpapAbs.dxaLeft += psep->xaLeft;
                    vpapAbs.dxaRight += psep->xaMac -
                                        (psep->xaLeft + psep->dxaText);
                    }
#ifdef INTL
                /* Ensure no pictures in Word documents. This is necessary
                   because Word 4.0 uses the fGraphics bit as part of the
                   new border type code (btc) property. */
        		if (vWordFmtMode == CONVFROMWORD)
                    vpapAbs.fGraphics = FALSE;
#endif
#ifdef BOGUS
 /* this would have erased all tab setting if saving back a Word document */

                /* For MEMO: the only tabs we write are in the first para run;
                   override all other tab tables to keep files compact */
                if (vpapAbs.rgtbd [0].dxa != 0)
                    bltc( vpapAbs.rgtbd, 0, cwTBD * itbdMax );
#endif
                FAddRun(fn, &fkp, &pchFprop, &prun, &vpapAbs, vppapNormal,
                    FParaEq( &vpapAbs, &pap ) ? -cchPAP : cchPAP,
                      vcpLimParaCache + cfcPage);
                blt(&vpapAbs, &pap, cwPAP);
                }
        WriteRgch(fn, &fkp, cbSector);
        Scribble(4,' ');

        if ((vfDiskFull || vfDiskError))
                goto AbortWrite;

        /* Output footnote table */
        Scribble(4,'F');
        (**hpfnfcb)[fn].pnFntb = (**hpfnfcb)[fn].pnMac;

#ifdef FOOTNOTES   /* In MEMO, we NEVER write a footnote table */
        if ((hfntb = HfntbGet(doc)) != 0)
                {
                WriteRgch(fn, *hfntb,
                    ((**hfntb).cfnd * cwFND + cwFNTBBase) * sizeof (int));
                AlignFn(fn, cbSector, false);
                }

        Scribble(4,' ');
        if ((vfDiskFull || vfDiskError))
                goto AbortWrite;
#endif  /* FOOTNOTES */

#ifdef CASHMERE     /* Output section properties, table from hsetb */
        /* Output section properties */
        Scribble(4,'S');
        (**hpfnfcb)[fn].pnSep = (**hpfnfcb)[fn].pnMac;
        if ((hsetb = HsetbGet(doc)) != 0)
                { /* Write out section props */
                cw = cwSETBBase + (**hsetb).csedMax * cwSED;
                csed = (**hsetb).csed;
                hsetbT = (struct SETB **) HAllocate(cw);
                if (FNoHeap(hsetbT))
                        return false;   /* SHOULD REALLY GOTO ABORTWRITE */
                blt(*hsetb, *hsetbT, cw);
                FreezeHp();
                for (psed = &(**hsetb).rgsed[0], psedT = &(**hsetbT).rgsed[0],
                  ised = 0;
                    ised < csed; psed++, psedT++, ised++)
                        if (psed->fc != fcNil)
                                { /* Copy props to file and update setb */
                                int cch;
                                pchFprop = PchFromFc(psed->fn, psed->fc, &cch);
                                Assert(cch >= *pchFprop + 1);
                                psedT->fn = fn;
                                AlignFn(fn, cch = *pchFprop + 1, false);
                                psedT->fc = (**hpfnfcb)[fn].fcMac;
                                WriteRgch(fn, pchFprop, cch);
                                }
                MeltHp();
                AlignFn(fn, cbSector, false);
                }

        Scribble(4,' ');
        if ((vfDiskFull || vfDiskError))
                goto AbortWrite;

        /* Output section table */
        (**hpfnfcb)[fn].pnSetb = (**hpfnfcb)[fn].pnMac;
        if (hsetb != 0)
            {
            if (csed != 1 || (**hsetb).rgsed[0].fc != fcNil)
                {
                WriteRgch(fn, *hsetbT,
                    ((**hsetb).csed * cwSED + cwSETBBase) * sizeof (int));
                AlignFn(fn, cbSector, false);
                }
            }
#else       /* MEMO VERSION: Write out a section table, 1 element long,
                             if we had nonstandard section properties */
        {
        typeFC fcSect;

            /* Output section properties */
        fcSect = (long)( cfcPage *
                         ((**hpfnfcb)[fn].pnSep = (**hpfnfcb)[fn].pnMac));

        if ((hsep = (**hpdocdod)[doc].hsep) != 0)
            {
            struct  {
                CHAR cch;
                struct SEP sep;
                }  fsep;
            fsep.cch = cchSEP;
            blt( *hsep, &fsep.sep, cwSEP );
            WriteRgch( fn, &fsep, sizeof( fsep ) );
            AlignFn( fn, cbSector, false );
            }

        if ((vfDiskFull || vfDiskError))
                goto AbortWrite;

            /* Output section table */
        (**hpfnfcb)[fn].pnSetb = (**hpfnfcb)[fn].pnMac;
        if (hsep != 0)
            {   /* Section table has 1 real + 1 dummy entry with cp==cpMac+1
                   This duplicates the output of PC Word 1.15 */
            struct {
                int csed;
                int csedMax;
                struct SED rgsed [2];
                } setb;

            setb.csed = setb.csedMax = 2;
            setb.rgsed [1].cp = 1 +
                               (setb.rgsed [0].cp = (**hpdocdod)[doc].cpMac);
            setb.rgsed [0].fn = fn;
            setb.rgsed [0].fc = fcSect;
            setb.rgsed [1].fn = fnNil;
            setb.rgsed [1].fc = fcNil;

            WriteRgch( fn, &setb, sizeof( setb ) );
            AlignFn( fn, cbSector, false );
            }
        }
#endif  /* not CASHMERE */

        if ((vfDiskFull || vfDiskError))
                goto AbortWrite;

        /* Output buffer or page table */
        (**hpfnfcb)[fn].pnBftb = (**hpfnfcb)[fn].pnMac;

#ifdef CASHMERE /* No docBuffer in WRITE */
        if(doc == docBuffer)
                {
                WriteBftb(fn);
                AlignFn(fn, cbSector, false);
                }
        else
#endif
        if ((hpgtb = HpgtbGet(doc)) != 0)
                {
                WriteRgch(fn, *hpgtb,
                    ((**hpgtb).cpgd * cwPGD + cwPgtbBase) * sizeof (int));
                AlignFn(fn, cbSector, false);
                }

        if ((vfDiskFull || vfDiskError))
                goto AbortWrite;

        /* Output font table */

#ifdef INTL /* International version */

        /* no font table if saving in Word format */
        if (vWordFmtMode != TRUE) /* no conv or conv from word */
#endif  /* International version */

            {
            Scribble(4,'N');
            (**hpfnfcb)[fn].pnFfntb = (**hpfnfcb)[fn].pnMac;
            WriteFfntb(fn, hffntb);         /* hffntb gets freed below */
            AlignFn(fn, cbSector, false);

            Scribble(4,' ');
            if ((vfDiskFull || vfDiskError))
                    goto AbortWrite;
            }

        /* Now update FIB at beginning of file */
        pfib = (struct FIB *) PchGetPn(fn, pn0, &cchT, true);
        pfib->pnPara = (pfcb = &(**hpfnfcb)[fn])->pnPara;
        pfib->pnFntb = pfcb->pnFntb;
        pfib->pnSep = pfcb->pnSep;
        pfib->pnSetb = pfcb->pnSetb;
        pfib->pnBftb = pfcb->pnBftb;

        /* mark file type if objects are in there */
        if (vcObjects)
            pfib->wIdent = wOleMagic;
        else
            pfib->wIdent = wMagic;

#ifdef INTL /* International version */

        if (vWordFmtMode != TRUE)  /* saving in Write format */
#endif  /* International version */

            {
            pfib->pnFfntb = pfcb->pnFfntb;
            pfib->pnMac = pfcb->pnMac;
            }

#ifdef INTL /* International version */

        else
            {
             /* in Word format there is no font table. pnFfntb is the
                end of the file,so is set to pnMac. The Write pnMac field
                is not used in Word and is set to 0. */
            pfib->pnFfntb = pfcb->pnMac;
            pfib->pnMac = 0;
            }
#endif  /* International version */

        pfib->fcMac = pfcb->fcMac = cpMac + cfcPage;
        if ((**hpdocdod)[doc].dty == dtyNormal)
                {
                CHAR (**hszSsht)[];
#ifdef STYLES
#ifdef DEBUG
                Assert((**hpdocdod)[doc].docSsht != docNil);
#endif
                hszSsht = (**hpdocdod)[(**hpdocdod)[doc].docSsht].hszFile;
#else
                hszSsht = HszCreate((PCH)"");
#endif /* STYLES */
                if (!FNoHeap(hszSsht))
                        {
                        bltbyte(**hszSsht, pfib->szSsht, CchSz(**hszSsht));
#ifndef STYLES                        
#if WINVER >= 0x300
                        /* Here we WERE allowing the hszSsht from just above
                           to be overwritten by another alloc!  This code 
                           really shouldn't even be here because Write knows
                           nothing about style sheets but we want to make as
                           few changes now as possible ..pault 2/12/90 */
                        FreeH(hszSsht);
#endif
#endif
                        hszSsht = HszCreate((PCH)pfib->szSsht); /* HEAP MOVES */
#if WINVER >= 0x300
                        /* Just in case hszSsht has already been assigned
                           here, we'll free it up ..pault 2/12/90 */
                        if ((**hpfnfcb)[fn].hszSsht != NULL)
                            FreeH((**hpfnfcb)[fn].hszSsht);
#endif
                        (**hpfnfcb)[fn].hszSsht = hszSsht;
                        }
                else
                        (**hpfnfcb)[fn].hszSsht = 0;
                }

AbortWrite:
        vfnWriting = fnNil;

        FreeFfntb(hffntb);

        if (vfDiskFull || vfDiskError) 
            fFileFlushed = FALSE;
        else    
            fFileFlushed = FFlushFn(fn);
        CloseEveryRfn( TRUE );

        if (!fFileFlushed)  /* Writing the file has failed due to disk full */
                {
#ifdef CASHMERE
                if (hsetb != 0)
                        FreeH(hsetbT);
#endif
LFlushFailed:
                FUndirtyFn(fn);  /* Undirty all of the buffer pages
                                    holding parts of the unsuccessfully
                                    written file. */
                return false;
                }

        if (!FMakeRunTables(fn)) /* HM */
                (**hpfnfcb)[fn].fFormatted = false;

        /* Success! */
#ifdef CASHMERE
        if (hsetb != 0)
                { /* HM */
                FreeH(hsetb);
                (**hpdocdod)[doc].hsetb = hsetbT;
                }
#endif
        }
else
        {
        WriteUnformatted(fn, doc);
        vfnWriting = fnNil;
        if (vfDiskFull || vfDiskError) 
            fFileFlushed = FALSE;
        else    
            fFileFlushed = FFlushFn(fn);
        CloseEveryRfn( TRUE );

        if (!fFileFlushed)
            goto LFlushFailed;
        }
CloseEveryRfn( TRUE );  /* Be real sure the save file is closed */
                        /* This fixes the "pasting between Write
                           instances with the sharer loaded" bug */


return true;
}





/*----------------------------------------------------------------------------
-- Routine: ReduceFnScratchFn
-- Description: this routine is called after successful TS, TGS, GTS and
    !vfBuffersDirty.  Its purpose is to make sure that no doc has pointers
    to fnScratch and that we can empty fnScratch so as to reduce program
    disk space
-- Arguments: none
-- Returns: none
-- Side Effects: docScrap is cleaned up and becomes a new doc that has no
    pointers into fnScratch.  FnScratch is emptied, all global variables
    associated with this new fnScratch are initialized.
-- Bugs:
-- History:
     Apr 16 '84 -- created (chic)
     Aug 9  '85 -- modified it so it puts the scratch file on the same disk
                   as the passed fn to reduce disk swapping on floppy
                   systems.
----------------------------------------------------------------------------*/

ReduceFnScratchFn( fn )
{
int        doc;
struct DOD *pdod;

CHAR       sz[cchMaxFile];

int        cchT;
struct FCB *pfcb;

#ifdef BOGUSBL  /* Because of disk switching, always worth doing */
if ((**hpfnfcb)[fnScratch].fcMac > fcBound)  /* worth doing */
#endif

    {
    for (pdod = &(**hpdocdod)[0],doc = 0; doc < docMac; pdod++,doc++)
        {
        /* don't do anything if any of the allocated doc (hpctb != 0)
           except docScrap is dirty */
        /* docUndo may be dirty, but it also should be empty */

        if (doc != docScrap && pdod->hpctb != 0 && pdod->fDirty &&
            doc != docUndo)
            {
            Assert(0);
            return;
            }
        } /* end of for loop */

    Assert( (**hpdocdod) [docUndo].cpMac == cp0 );

    /* now no doc can possibly has pointers to fnScratch except docScrap */
    pdod = &(**hpdocdod)[docScrap];


#if 0 
        This check was only for speed considerations.  With the 64K
        transcendence we *must* clean docScrap no matter what.
        (7.10.91) v-dougk

    if (pdod->cpMac > cpBound) /* too big to be cleaned up */
    {
        Assert(0);
        /** 
            But we don't know if docScrap points into fnScratch.  We only need
            to clear docScrap if it points into fnScratch.  We shouldn't
            abort here unless we know that docScrap does indeed point into 
            fnScratch.  If it doesn't then we needn't clear it and can proceed
            to clear fnScratch.

            We know that docScratch will not point to any large 
            OLE object data in fnScratch because object data is never put 
            into fnScratch at a time that the user could select it.
            That is, it is unlikely that the size of docScratch will
            exceed cpBound on account of object data alone.

            Only the presence of large textual data in docScratch 
            is likely to cause this failure.
            (7.10.91) v-dougk
         **/
        return;
    }
    else    /* small enough to be cleaned up */
#endif
        {
        if (pdod->cpMac > cp0)
            {
#ifdef STYLES
            /* doc has to have a valid style sheet before CleanDoc */
            pdod->docSsht = (**hpdocdod)[docCur].docSsht;
#endif /* STYLES */
            CachePara(docScrap,cp0);

                /* Save docScrap to new, unique file; name in sz */
            CleanDoc( docScrap, dtyNetwork, sz, true, false );
#ifdef STYLES
            (**hpdocdod)[docScrap].docSsht = docNil;
#endif /* STYLES */
            }
        if (!ferror)  /* in case something went wrong in rename or make backup file in CleanDoc */
            {
            typePN pnMacScratch;

            pfcb = &(**hpfnfcb)[fnScratch];
            pnMacScratch = pfcb->pnMac;
            ResetFn(fnScratch); /* empty FnScratch */

#ifdef DEBUG
            OutputDebugString("*** Reduced scratch file ***\n\r");
#endif

            /* Put the scratch file on the same disk as the save file,
               to reduce disk swapping in floppy environments */

            if ( (fn != fnNil) &&
             !((POFSTRUCT)(**hpfnfcb) [fnScratch].rgbOpenFileBuf)->fFixedDisk )
                {   /* fnScratch is on removable media */
                extern CHAR szExtDoc[];
                CHAR szNewScratch[ cchMaxFile ];
                CHAR (**hszScratch)[] = (**hpfnfcb) [fnScratch].hszFile;
                CHAR chDrive = (**(**hpfnfcb) [fn].hszFile) [0];

                Assert( fn != fnScratch );
                if (FEnsureOnLineFn( fn ))
                    if (GetTempFileName( TF_FORCEDRIVE | chDrive,
                               (LPSTR)(szExtDoc+1), 0, (LPSTR) szNewScratch))
                        {   /* Created new file on same disk as fn */
                        CHAR (**hsz)[];
                        CHAR szNew [cchMaxFile];

#if WINVER >= 0x300            
            /* Currently: FNormSzFile  *TAKES*   an OEM sz, and
                                      *RETURNS*  an ANSI sz ..pault */
#endif
                        FNormSzFile( szNew, szNewScratch, dtyNormal );
                        if (!FNoHeap( hsz = HszCreate(szNew)))
                            {
                            struct FCB *pfcb = &(**hpfnfcb)[fnScratch];

                            /* Delete old scratch file */

                            if (FEnsureOnLineFn( fnScratch ))
                                FDeleteFile( &(**hszScratch)[0] );

                            /* Put new scratch file back on line and
                               open it, so OpenFile gets its buffer info */

                            pfcb->hszFile = hsz;
                            pfcb->fOpened = FALSE;

                            FEnsureOnLineFn( fn );
                            FAccessFn( fnScratch, dtyNormal);
                            }
                        }
                }

            pfcb->pnMac = pnMacScratch;
            /* reset all global varibales associated with an empty fnScratch */
            fprmCache.cch = 0;
            fcMacPapIns = 0;
            fcMacChpIns = 0;
            /* just in case */
            pfcb->pnChar = pfcb->pnPara = pfcb->pnFntb = pfcb->pnSep = pfcb->pnSetb = pfcb->pnBftb = pn0;
            vfkpdParaIns.brun = vfkpdCharIns.brun = 0;
            vfkpdParaIns.bchFprop = vfkpdCharIns.bchFprop = cbFkp;
            vfkpdParaIns.pn = PnAlloc(fnScratch);
            ((struct FKP *)PchGetPn(fnScratch, vfkpdParaIns.pn,
                                    &cchT, true))->fcFirst = fc0;
            vfkpdCharIns.pn = PnAlloc(fnScratch);
            ((struct FKP *)PchGetPn(fnScratch, vfkpdCharIns.pn,
                                    &cchT, true))->fcFirst = fc0;
            vfkpdParaIns.ibteMac = vfkpdCharIns.ibteMac = 0;
            blt(&vchpNormal, &vchpInsert, cwCHP);
            blt(vppapNormal, &vpapPrevIns, cwPAPBase + cwTBD);
            } /* end of ferror */
            else
                Assert(0);
        } /* end of small enough to be cleaned up */
    } /* end of worth doing */
} /* end of ReduceFnScratchFn */






ResetFn(fn)
{ /* make fn look as if no characters have been written */
  /* but don't try to reuse fn (in that case, must rehash) */
int ibp;
register struct BPS *pbps;
struct FCB *pfcb;

Assert( fn != fnNil );
(pfcb = &(**hpfnfcb)[fn])->fcMac = fc0;
pfcb->pnMac = pn0;
for (ibp = 0, pbps = &mpibpbps [0]; ibp < ibpMax; ++ibp, ++pbps)
        {    /* find all buffer pages and "clear" them */
        if (pbps->fn == fn)
                {
#ifdef CKSM
#ifdef DEBUG
                extern unsigned (**hpibpcksm) [];

                if (!pbps->fDirty)
                    Assert( (**hpibpcksm) [ibp] == CksmFromIbp( ibp ) );
#endif
#endif
                pbps->fDirty = false;
                pbps->cch = 0;
#ifdef CKSM
#ifdef DEBUG
                    /* Recompute checksum to account for cch change */
                (**hpibpcksm) [ibp] = CksmFromIbp( ibp );
#endif
#endif
                }
        }
}



/***        FBackupSzFile - Make a backup copy of the passed szFile
 *
 *  ENTRY:  szFile - the (assumed normalized) name of the
 *                   file to back up
 *          fBackup - whether the user is interested in seeing
 *                    a backup copy of szFile
 *  EXIT:   szBak - the (normalized) name of the backup
 *                  file is returned through here
 *  RETURNS:    TRUE=We made a backup copy, szBak of szFile
 *              FALSE=We didn't/couldn't make a backup copy
 *
 *  NOTE: We try to put the backup file into the directory used
 *        as the default by GetTempFileName; in general, this
 *        effort will succeed if the directory is on the same
 *        physical drive as the original.
 *  NOTE: we may keep around a backup copy regardless of the
 *  setting of fBackup, to have access to pieces in it.
 *  However, the file's fDelete flag will be set to TRUE, marking
 *  it for eventual deletion
 */

FBackupSzFile( szFile, fBackup, szBak )    /* filenames taken as ANSI */
CHAR szFile[];
int     fBackup;
CHAR szBak[];
{ /* Copy szFile into a backup copy, and give backup old fn. */
  /* Also, return name of backup file */
int fnOld;
int f;
int fDelete = false;
int rfn;
int fTryAgain=FALSE;
CHAR chDriveTempFile;
int fn;
CHAR rgbBuf[ cbOpenFileBuf ];

#ifdef ENABLE
 if ((fn = FnFromSz( szFile )) != fnNil)
        /* Avoid share violations while checking for existence */
    CloseFn( fn );
 if (OpenFile( (LPSTR) szFile, (LPOFSTRUCT) rgbBuf, OF_EXIST ) != -1)
#endif

 if (FExistsSzFile( dtyAny, szFile ))
    {   /* File exists; make backup (even if it's on another floppy) */
    int fSame;

        /* szBak <-- backup file name (it'll be normalized since szFile is) */
    bltsz( szFile, szBak );

#ifdef INTL /* International version */
     /* if file has .WRI extension, put Write .BKP extension on, 
        otherwise put Word backup extension (.BAK) on instead. */

    AppendSzExt( szBak, szExtDoc, TRUE );
    fSame = FSzSame( szFile, szBak );   /* Whether file is .WRI */
    AppendSzExt( szBak, (fSame ? szExtBackup : szExtWordBak),
                TRUE );
#else
    AppendSzExt( szBak, szExtBackup, TRUE );
#endif  /* International version */


    fSame = FSzSame( szFile, szBak );   /* Whether file is .BAK already */

    Assert( szBak [1] == ':' );
    chDriveTempFile = szBak[0];    /* Drive on which to create temp file */

    for( ;; )
        {

        if (!fBackup || fSame )
            {    /* This is just being kept for its pieces OR the file
                    happens to be .BAK already: give backup a unique name */
            CHAR szBakT [cchMaxFile];

            if (!fTryAgain)
                {   /* First time through; try not forcing the drive
                       letter to see how we fare.  The advantage is that
                       if we succeed, the temp file is in a more standard
                       place. If the rename fails, we end up at the
                       branch below. */

                fTryAgain = TRUE;       /* Try a second time if we fail */
                if (!GetTempFileName( chDriveTempFile, 
                                      (LPSTR)(szExtDoc+1), 0, (LPSTR)szBakT))
                    continue;
                }
            else
                {   /* Second time through -- try forcing the drive */
                    /* Grab a temp file on the same drive as the original */

                fTryAgain = FALSE;  /* No more tries */
                if (!GetTempFileName( chDriveTempFile | TF_FORCEDRIVE,
                                      (LPSTR)(szExtDoc+1), 0, (LPSTR) szBakT))
                    {
                    Error( IDPMTSDE2 ); /* should probably GOTO HARDCORE instead */
                    return FALSE;
                    }
                }

                /* szBakT <-- Temp name in OEM */
                /* szBak  <-- Normalized temporary name in ANSI */
            FNormSzFile( szBak, szBakT, dtyNormal );
            fDelete = TRUE;
            }

        if ((fnOld = FnFromSz(szBak)) != fnNil)
            { /* We have backup open */
            CHAR szT[cchMaxFile];

            FBackupSzFile( szBak, false, szT );
            }

        if ((fnOld = FnFromSz(szFile)) != fnNil)
            { /* We have file open */
/* ? */     FFlushFn(fnOld);
            CloseFn( fnOld );
            }

        /* Rename szFile to be temp name (must delete the empty temp file) */

        if (!FDeleteFile( szBak ) || FIsErrFpe(FpeRenameFile( szFile, szBak )))
            {
            extern HWND vhWnd;
            CHAR szT [cchMaxSz];
            CHAR *pchSrc;

            if (fTryAgain)
                    /* Failed with temp name on the default drive; try again */
                continue;

            /* HARDCORE FAILURE: Could not rename file */
HardCore:
            /* pchSrc <-- ptr to start of filename (sans path) */

            pchSrc = &szFile [CchSz( szFile ) - 1];
            while (pchSrc > szFile)
                if (*(--pchSrc) == '\\')
                    {
                    pchSrc++;
                    break;
                    }
            Assert( pchSrc > szFile );  /* Always "X:\" in normalized name */

            MergeStrings (IDPMTRenameFail, pchSrc, szT);
            IdPromptBoxSz( vhWnd, szT, ErrorLevel( IDPMTRenameFail ) );

            return FALSE;  /* We couldn't rename this file to the backup name */
            }

        if (fnOld != fnNil)
            {   /* We had an fn for the renamed file; must update fcb */
            CHAR (**hszBak)[];
            struct FCB *pfcb;

            FreeH((**hpfnfcb)[fnOld].hszFile);  /* HM */
            hszBak = HszCreate((PCH)szBak);

            pfcb = &(**hpfnfcb)[fnOld];
            pfcb->hszFile = hszBak;
            pfcb->fDelete = fDelete;
            }

        else if (!fBackup)
            {   /* Delete this sucker NOW. (!fBackup indicates that the user
                   doesn't care about the backup copy, and Word can't care
                   about its pieces since it doesn't have an fn. So nobody
                   wants it, so we get rid of it) */
            FDeleteFile( szBak );
            return false;
            }

        return true;
        }   /* end   for( ;; ) */
    }   /* end if (FExists... */


return false;   /* file did not exist; make no backup */
}





int FExistsSzFile(dty, szFile)
int dty;
CHAR szFile[];
{ /* Return true iff file exists */
CHAR rgbBuf[ 128 ];     /* Buffer used by OpenFile */
int bRetval;

#ifdef DEBUG
    {
    int junk;
    Assert(FValidFile(szFile, CchSz(szFile)-1, &junk));
    }
#endif /*DEBUG*/

/* Use FnFromSz to avoid share violations on files we have open */

    if (FnFromSz( szFile ) != fnNil)
        return TRUE;

    SetErrorMode(1);
    bRetval = OpenFile( (LPSTR) szFile, (LPOFSTRUCT) rgbBuf, OF_EXIST ) != -1;
    SetErrorMode(0);
    return bRetval;
}





struct PGTB **HpgtbGet(doc)
int doc;
{ /* Return hpgtb if doc has one, 0 if none  */
struct DOD *pdod;

if ((pdod = &(**hpdocdod)[doc])->dty != dtyNormal)
        return 0;
else
        return pdod->hpgtb;
}





FreeFn( fn )
int fn;
{   /* Forget about the existence of file fn.  Assumes no document holds
       pieces from fn.  Frees all heap items in (**hpfnfcb) [fn] and
       marks the fcb as free (rfn == rfnNil).
      */
#define IibpHash(fn,pn) ((int) ((fn + 1) * (pn + 1)) & 077777) % iibpHashMax

 extern int iibpHashMax;
 extern CHAR *rgibpHash;
 extern struct BPS *mpibpbps;

 register struct BPS *pbps;
 int pn;

 extern CHAR (**hszTemp)[];

 register struct FCB *pfcb = &(**hpfnfcb)[fn];
 CHAR (**hsz)[] = pfcb->hszFile;
 CHAR (**hszSsht)[] = pfcb->hszSsht;
 typeFC (**hgfcChp)[]=pfcb->hgfcChp;
 typeFC (**hgfcPap)[]=pfcb->hgfcPap;

 FreezeHp();

 CloseFn( fn );

/* Purge buffer slots holding pages of fn; maintain integrity of hash chains */

 for ( pn = 0; pn < pfcb->pnMac; pn++ )
    FreeBufferPage( fn, pn );

#ifdef DEBUG
 CheckIbp();
#endif

 pfcb->fDelete = FALSE;
 pfcb->hszFile = hszTemp;
 pfcb->rfn = rfnFree;
 MeltHp();

 if ( hsz != hszTemp )
    FreeH( hsz );
#if WINVER >= 0x300
 /* Previously we allocated a small block ("") for the 
    style sheet but never freed it!  ..pault 2/12/90 */
 if (hszSsht != NULL)
    FreeH(hszSsht);
#endif
 if (hgfcChp)
    FreeH( hgfcChp );
 if (hgfcPap)
    FreeH( hgfcPap );
}




/***          FUndirtyFn
 *
 *
 */

FUndirtyFn(fn)
int fn;
/*
        Description:    Mark all buffer pages holding parts of this file
                        as non-dirty.
                        Called after a disk full caused writing a file
                        to fail (in FWriteFn).
        Returns:        nothing.
*/
{
#ifdef CKSM
#ifdef DEBUG
        extern unsigned (**hpibpcksm) [];
#endif
#endif
        int ibp;
        struct BPS *pbps;
        for (ibp = 0, pbps = mpibpbps; ibp < ibpMax; ibp++,
                                                     pbps++)
                {
                if (pbps->fn == fn) 
                    {
                    pbps->fDirty = FALSE;
#ifdef CKSM
#ifdef DEBUG
                    /* Update checksum */
                    (**hpibpcksm) [ibp] = CksmFromIbp( ibp );
#endif
#endif
                    }
                }

}




/***        IbpWriting - Find buffer page while writing file
 *
 *
 *
 */

IbpWriting(fn)
int fn;
/* called when trying to find a slot in the file page "cache" buffer and */
/* vfnWriting != fnNil (currently in the process of writing some file) */
{
        typeTS dTs;
        int ibp;

        if (fn == vfnWriting)
                {       /* writing a piece of the vfnWriting file */
                /* vibpWriting is the previous slot used to hold file */
                /* contents.  Keep slots contiguous and in the first */
                /* (upper) half of the buffer area. */
                if (vibpWriting > 0)
                    {   /* We may have read multiple pages last time */
                        /* Advance past all slots holding contiguous pages */
                    struct BPS *pbps=&mpibpbps[ vibpWriting ];
                    int pn=(pbps-1)->pn;

                    while ( pbps->fn == fn && pbps->pn == ++pn )
                        {
                        pbps++;
                        vibpWriting++;
                        }
                    vibpWriting--;
                    }

                if (++vibpWriting >= (ibpMax >> 1))
                        vibpWriting = 0;

                /* We must abide by the restriction that */
                /* we do not clobber the cbpMustKeep most recently used */
                /* slots in the process. */
                dTs = tsMruBps - mpibpbps[vibpWriting].ts;
                dTs = ((dTs & 0x8000) ? (~dTs + 1) : dTs);/* absolute value */
                if (dTs < cbpMustKeep)
                        vibpWriting = ibp = IbpLru(0);
                else    /* adjacent slot is o.k. - not too recently used */
                        ibp = vibpWriting;
                }
        else
                /* If currently writing a file (but the current page is */
                /* not part of it), try to find a slot in the lower half */
                /* of the buffer.  This decreases the possibility that the */
                /* adjacent slot to vibpWriting will be too recently used. */
                ibp = IbpLru(ibpMax >> 1);
        return(ibp);
}




WriteFfntb(fn, hffntb)
int fn;
struct FFNTB **hffntb;
{       /* Append a font table (ffntb) to fn */
struct FFNTB *pffntb;
struct FFN *pffn;
int iffn, cbffn;
int cchPageSpace = cbSector;
int cchWrite;
int wEndOfPage = -1;
int wEndOfTable = 0;
int cbT;

pffntb = *hffntb;
cbT = pffntb->iffnMac;
WriteRgch( fn, &cbT, sizeof (int) );
cchPageSpace = cbSector - sizeof (int);

for (iffn = 0; iffn < pffntb->iffnMac; iffn++)
    {
    pffn = *pffntb->mpftchffn[iffn];
    cchWrite = (cbffn = CbFfn(CchSz(pffn->szFfn))) + (2 * sizeof(int));

    if (cchWrite > cchPageSpace)
        {   /* This entry will not fit on the page; start new page */

        Assert( cchPageSpace >= sizeof (int ));
        WriteRgch( fn, &wEndOfPage, sizeof (int) );
        AlignFn( fn, cbSector, false );
        cchPageSpace = cbSector;
        }

    Assert( cchWrite <= cchPageSpace );

#ifdef NEWFONTENUM
    /* let's just pretend we never added a charset field... pault */
    cbffn -= sizeof(BYTE); 
    WriteRgch( fn, &cbffn, sizeof (int) );  /* Write entry size in bytes */
    WriteRgch( fn, &pffn->ffid, cbffn );    /* Write the entry */
#else
    WriteRgch( fn, &cbffn, sizeof (int) );  /* Write entry size in bytes */
    WriteRgch( fn, pffn, cbffn );           /* Write the entry */
#endif
    cchPageSpace -= cbffn + sizeof (int);
    }

Assert( cchPageSpace >= sizeof (int) );
WriteRgch( fn, &wEndOfTable, sizeof(int) ); /* Table is terminated with 0000 */
}



FMapFtcSave(doc, hffntb, pchp, mpftcftc)
/* attempt to map the ftc for this chp into it's new ftc in hffntb, according
   to the mapping in mpftcftc.  If there's no entry yet for this ftc, then
   add it to the table.  Returns FALSE if there was some problem */

int doc;
struct FFNTB **hffntb;
struct CHP *pchp;
CHAR *mpftcftc;
{
int ftc, ftcNew;
struct FFN *pffn;
CHAR rgbFfn[ibFfnMax];

ftc = pchp->ftc + (pchp->ftcXtra << 6);
ftcNew = mpftcftc[ftc];
if (ftcNew == ftcNil)
        {
        /* haven't encountered this font yet - add it to hffntb and mpftcftc */
        pffn = *(*HffntbGet(doc))->mpftchffn[ftc];
        bltbyte(pffn, rgbFfn, CbFromPffn(pffn));
        ftcNew = FtcAddFfn(hffntb, pffn);
        if (ftcNew == ftcNil)
                /* some problem adding the font */
                return(FALSE);
        mpftcftc[ftc] = ftcNew;
        }

pchp->ftc = ftcNew & 0x003f;
pchp->ftcXtra = (ftcNew & 0x00c0) >> 6;
return(TRUE);
}



FInitMapSave(doc, phffntb, mpftcftc)
/* sets up for ftc mapping */

int doc;
struct FFNTB ***phffntb;
CHAR *mpftcftc;
{
bltbc( mpftcftc, ftcNil, iffnMax );
return(FNoHeap(*phffntb = HffntbAlloc()) == FALSE);
}




/* O U T  S A V E D */
OutSaved(doc)
int doc;
{
 extern int docMode;
 extern CHAR szMode[]; 
 int NEAR CchExpCp( CHAR *, typeCP );
 char szTmp[cchMaxSz];

 LoadString(hINSTANCE, IDSTRChars, szTmp, sizeof(szTmp));
 wsprintf(szMode,szTmp,(DWORD)(**hpdocdod)[doc].cpMac);
 docMode = docNil;
 DrawMode();
}




/* C C H  E X P  C P */
int NEAR CchExpCp(pch, cp)
CHAR *pch;
typeCP cp;
{
        int cch = 0;

        if (cp >= 10)
                {
                cch = CchExpCp(pch, cp / 10);
                pch += cch;
                cp %= 10;
                }
        *pch = '0' + cp;
        return cch + 1;
}



#if 0

SaveFontProfile(doc)
/* updates our mru font entries in win.ini */

int doc;
    {
    extern CHAR szWriteProduct[];
    extern CHAR szFontEntry[];
    int iffn;
    struct FFN *pffn;
    CHAR *pchFontNumber, *pchT;
    CHAR rgbProf[LF_FACESIZE + 10]; /* for good measure */
    CHAR rgbFfn[ibFfnMax];

    if (FInitFontEnum(doc, iffnProfMax, FALSE))
        {
        pffn = (struct FFN *)rgbFfn;
        pchFontNumber = szFontEntry + CchSz(szFontEntry) - 2;
        for (iffn = 0; iffn < iffnProfMax; iffn++)
            {
            if (!FEnumFont(pffn))
                break;
#ifdef NEWFONTENUM
#endif
            pchT = (CHAR *)bltbyte(pffn->szFfn, rgbProf, CchSz(pffn->szFfn))-1;
            *pchT++ = ',';
            ncvtu(pffn->ffid, &pchT);
#ifdef NEWFONTENUM
            /* Save the font's charset value as well */
            *pchT++ = ',';
            ncvtu(pffn->chs, &pchT);
#endif
            *pchT = '\0';

            *pchFontNumber = '1' + iffn;
            WriteProfileString((LPSTR)szWriteProduct, (LPSTR)szFontEntry,
                (LPSTR)rgbProf);
            }
        EndFontEnum();
        }
    }

#endif