windows-xp/Source/XPSP1/NT/base/mvdm/wow16/write/initmmw.c

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

/* initialization codes for internal memory, page buffers, etc. */
#define NOKEYSTATE
#define NOCLIPBOARD
#define NOGDICAPMASKS
#define NOCTLMGR
#define NOVIRTUALKEYCODES
#define NOWINMESSAGES
#define NOSYSMETRICS
#define NOSYSCOMMANDS
#define NOCOLOR
#define NOCREATESTRUCT
#define NOCTLMGR
#define NODRAWTEXT
#define NOSHOWWINDOW
//#define NOATOM
#define NOMENUS
#define NOICON
#define NOKEYSTATE
#define NOSHOWWINDOW
#define NOBITMAP
#define NOSOUND
#define NOCOMM
#define NOOPENFILE
#define NORESOURCE
#define NOMETAFILE
#define NOPEN
#define NOREGION
#define NOSCROLL
#define NOWH
#define NOWINOFFSETS
/* need gdi, hdc, memmgr */
#include <windows.h>

#include "mw.h"
#define NOUAC
#include "cmddefs.h"
#include "wwdefs.h"
#include "docdefs.h"
#include "editdefs.h"
#include "propdefs.h"
#include "fmtdefs.h"
#include "filedefs.h"
#include "fkpdefs.h"
#include "stcdefs.h"
#ifdef CASHMERE
#include "txb.h"
#endif /* CASHMERE */
#include "fontdefs.h"
#include "code.h"
#include "heapdefs.h"
#include "heapdata.h"
#include "str.h"
#include "ch.h"
#if defined(OLE)
#include "obj.h"
#endif

#ifdef DEBUG
#define STATIC
#else
#define STATIC static
#endif

/* E X T E R N A L S */
extern int              ypMaxWwInit;
extern int              dypWwInit;
extern int              *memory;
extern int              *pmemMax;
extern CHAR             *pmemStart;
extern unsigned         vcbMemTotal;
extern HWND             hParentWw;
extern HDC              vhDCPrinter;
extern int              rfnMac;
extern CHAR             (*rgbp)[cbSector];
extern int              fnMac;
extern typeTS           tsMruRfn;
extern struct ERFN      dnrfn[];
extern CHAR             *rgibpHash;
extern struct BPS       *mpibpbps;
extern typeTS           tsMruBps;
extern struct CHP       vchpNormal;
extern struct PAP       *vppapNormal;
extern struct SEP       vsepNormal;
extern struct CHP       (**vhgchpFormat)[];
extern int              ichpMacFormat;
extern struct CHP       vchpInsert;
extern struct CHP       vchpSel;
extern struct FCB       (**hpfnfcb)[];
extern struct FKPD      vfkpdCharIns;
extern struct FKPD      vfkpdParaIns;
extern struct PAP       vpapPrevIns;
extern struct FLI       vfli;
extern int              docMac;
extern struct DOD       (**hpdocdod)[];
extern int              docScrap;
extern int              docUndo;
#ifdef CASHMERE /* No docBuffer in WRITE */
extern int              docBuffer;
#endif
extern int              docCur;
extern CHAR             (**hszSearch)[];
extern CHAR             (**hszReplace)[];
extern CHAR             (**hszFlatSearch)[];
extern CHAR             stBuf[];
extern int              vrefSystem;
extern CHAR             (**vhrgbSave)[];
extern int              vdxaPaper;
extern int              vdyaPaper;
extern struct SEL       selCur;
extern BOOL             vfPrinterValid;
extern int              dxaPrPage;
extern int              dyaPrPage;
extern int              dxpPrPage;
extern int              dypPrPage;
extern int              dxaPrOffset;
extern int              dyaPrOffset;
extern HCURSOR          vhcArrow;
#ifdef UNUSED
extern int  vfCanPrint;
#endif

//Win3.1J
#if defined(JAPAN) & defined(DBCS_IME) /* Doc for Insert IR_STRING from IME */
extern int     docIRString;
#endif

/* G L O B A L S -- used only in here */
int                     rgwPapNormal[cwPAPBase + cwTBD] = {0};


#ifdef STATICPAGES
#ifdef MACHA
#define                 ibpMaxStatic  79
#define                 iibpHashMaxStatic  163
#else /* not MACHA */
#define                 ibpMaxStatic  7
#define                 iibpHashMaxStatic  17
#endif /* MACHA */
CHAR                    rgbpStatic[ibpMaxStatic][cbSector];
#endif /* STATICPAGES */

extern typePN PnAlloc();

STATIC int NEAR FInitDocs( void );
STATIC int NEAR FInitProps( void );
STATIC int NEAR FInitFiles( void );
WORD wWinVer,fPrintOnly=FALSE;

int FInitMemory()
{
extern HANDLE vhReservedSpace;
int i;

#ifdef UNUSED
/* Initially assume that it is not possible to print  */
/* Formerly InitPrint was called here    */
        vfCanPrint =  false;
#endif

    /** This is a glitch so that the fixed array for storing relocation
        information will be created immediately */
    wWinVer = (WORD)(GetVersion() & 0x0000FFFFL);
    if (((wWinVer & 0xFF) >= 3) && ((wWinVer & 0xFF00) >= 0x0A00))
    /* Windows Version >= 3.10 */
    {
        FARPROC LHandleDelta = GetProcAddress(GetModuleHandle((LPSTR)"KERNEL"),(LPSTR)0x136L);
        i = LHandleDelta(0);
        LHandleDelta(i*5); /* make a big finger table */
        vhReservedSpace = LocalAlloc(LHND, cbReserve);
        LocalFree(vhReservedSpace);
        LHandleDelta(i); /* resume to a smaller finger table if needed more */
    }
    else
    /* Windows Version < 3.10 */
    {
        /**
            This is heaping kludge upon kludge in the effort to be backwards
            compatible with past kludges.  This is the old macro which with
            Win31 has become a function call. (3.11.91) D. Kent
        **/
#define LocalHandleDelta(d) ((d) ? (*(pLocalHeap+9) = (d)) : *(pLocalHeap+9))
        i = LocalHandleDelta(0);
        LocalHandleDelta(i*5); /* make a big finger table */
        vhReservedSpace = LocalAlloc(LHND, cbReserve);
        LocalFree(vhReservedSpace);
        LocalHandleDelta(i); /* resume to a smaller finger table if needed more */
    }

#ifdef OURHEAP
/* reserve 1K for windows's memory manager for creating dialog boxes */
        vhReservedSpace = LocalAlloc(LPTR, cbReserve);

        CreateHeapI(); /* create heap first */
        if (!FCreateRgbp())  /* rgbp are expandable */
            return FALSE;

/* now free the reserved space after our memory is set up. */
/* hopefully we will get all the fixed objects created by
   dialog manager be placed above our memory chunk, so we can still
   expand our heap while a dialog box is up. */
        LocalFree(vhReservedSpace);
#else
        if (!FCreateRgbp())
            return FALSE;
        vhReservedSpace = LocalAlloc(LHND, cbReserve); /* this is to make
        discardable when we are out of memory and try to bring up the
        save dialog box */
#endif

        if (vhReservedSpace == NULL)
            return FALSE;

/* formerly CreateHpfnfcb */
        hpfnfcb = (struct FCB (**)[])HAllocate(cwFCB * fnMax);
        if (FNoHeap(hpfnfcb))
            return FALSE;
        fnMac = fnMax;
        for (i = 0; i < fnMac; i++)
            (**hpfnfcb)[i].rfn = rfnFree;
/* end of CreateHpfnfcb */

        if (!FSetScreenConstants())
            return FALSE;

        if ( !FInitDocs() ||
#ifdef CASHMERE     /* No glossary in MEMO */
             !FInitBufs() ||
#endif  /* CASHMERE */
             !FInitProps() ||
             !FInitFiles() )
            return FALSE;

/* allocate emergency space for save operations */
        if (FNoHeap(vhrgbSave = (CHAR (**)[])HAllocate(cwSaveAlloc)))
            return FALSE;

        return TRUE;
}
/* end of  F I n i t M e m o r y  */




int FInitArgs(sz)
CHAR *sz;
{   /*  Set extern int docCur to be a new doc, containing
        the file (if any) specified on the command line (sz).

        Initialize a wwd (window descriptor) structure for the document
        and set an appropriate title into the title bar.

        Set selCur to be an insertion point before the first char of the doc,
        and set vchpSel to be the char properties of the insertion point.

        Return TRUE if all is well, FALSE if something went wrong.
        A return of FALSE means that initialization should not continue.
        */

        extern typeCP cpMinDocument;
        extern struct WWD rgwwd[];
        extern int vfDiskError;
        extern int vfSysFull;
        extern int ferror;
        extern BOOL vfWarnMargins;

        int fn, doc;
        RECT rcCont;
        CHAR szT [ cchMaxFile ];
        register CHAR *pch;
                CHAR ch;
        int fEmptyLine = TRUE;
        CHAR (**hsz) [];
        int iT, cbsz;

#ifdef INTL /* International version */
        int fWordDoc = FALSE;
#endif  /* International version */

        /* Decide whether we have anything but white space on the command line */

        for ( pch = sz; (ch = *pch) != '\0'; pch++ )
            if ((ch != ' ') && (ch != '\011'))
                {
                fEmptyLine = FALSE;
                break;
                }

        if (fEmptyLine)
                /* No filename; start with (Untitled) */
            goto Untitled;

        cbsz = CchSz (sz ) - 1;
           /* remove trailing spaces from sz */
        for ( pch = sz + cbsz - 1; pch >= sz; pch-- )
            if (*pch != ' ')
                break;
            else
                {
                *pch = '\0';  /* replace with null */
                cbsz--;
                }

        /* check for /p option (6.26.91) v-dougk */
        if ((sz[0] == '/') && (sz[1] == 'p'))
        {
            sz += 2;
            cbsz -= 2;
            fPrintOnly = TRUE;
            for (; *sz; sz++, cbsz-- ) // get to filename
                if ((*sz != ' ') && (*sz != '\011'))
                    break;

            if (!*sz) /* No filename, abort */
                return FALSE;
        }

        /* convert to OEM */
        AnsiToOem(sz, sz);

        if (!FValidFile( sz, cbsz, &iT ) ||
             !FNormSzFile( szT, sz, dtyNormal ))
            {   /* Bad filename -- it could not be normalized */
            extern int vfInitializing;
            char szMsg[cchMaxSz];
            char *pch;
            extern HWND vhWndMsgBoxParent;
            extern HANDLE hParentWw;

            vfInitializing = FALSE; /* Do not suppress reporting this err */
            MergeStrings (IDPMTBadFileName, sz, szMsg);
            /* if we're being called from a message box, then use it
               as the parent window, otherwise use main write window */
            IdPromptBoxSz(vhWndMsgBoxParent ? vhWndMsgBoxParent : hParentWw,
                          szMsg, MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL);
            ferror = TRUE; /* need to flag */
            vfInitializing = TRUE;
            goto Untitled;
            }

        if ((fn = FnOpenSz( szT, dtyNormal,
               index( szT, '/' ) == NULL &&
               index( szT,':') == NULL && index( szT, '\\') == NULL )) != fnNil)
                /* Opened file OK -- prefetch file contents into rgbp */
        {

#ifdef INTL /* Kanji / International version */
              /* **************************************
              * added check for international version to
                 do Word format conversion. If Word format,
                 bring up another dialog box.
              * ************************************** */

                  /* TestWordCvt return values:

                    -1 means dialog box failed (error already sent)
                       or cancel without conversion.
                    FALSE means not a word document.
                    TRUE means convert this word document.
                        vfBackupSave is changed to reflect whether
                        save is done with backup.
                      */

#ifdef KKBUGFIX     //  added by Hiraisi (BUG#2816 WIN31) in Japan
            if ((fWordDoc = TestWordCvt (fn, (HWND)NULL)) == -1  ||
                 fWordDoc == -2)
#else
            if ((fWordDoc = TestWordCvt (fn, (HWND)NULL)) == -1)
#endif
                goto Untitled;
                /* if fWordDoc is true, will convert later */
#endif  /* International version */


            StartLongOp();
            ReadFilePages( fn );
            EndLongOp(vhcArrow);
        }
        else /* Could not open file  */
        {
            if (fPrintOnly)
                return FALSE;
            else
            {   /* use (Untitled) */
Untitled:
            fn = fnNil;
            sz [0] = '\0';
            szT [0] = '\0';
            }
        }

        if (vfDiskError || vfSysFull)
                /* Serious disk error OR disk holding scratch file is full --
                   bail out */
            return FALSE;

        if (fn != fnNil)
            {   /* Opened file OK -- must account for the case when OpenFile
                   returned a filename that differed from the one given it */

            bltsz( &(**(**hpfnfcb) [fn].hszFile) [0], szT );
            }

        if (FNoHeap(hsz=HszCreate( (PCH) szT )) ||
            (doc=DocCreate( fn, hsz, dtyNormal )) == docNil)
            {   /* Could not create a doc */
            return FALSE;
            }
        if (WwNew(doc, dypWwInit, ypMaxWwInit) == wwNil)
            return FALSE;
        NewCurWw(0, true);
        if (fn != fnNil)
            {
            vfWarnMargins = TRUE;
            SetPageSize();
            vfWarnMargins = FALSE;
            }
        wwdCurrentDoc.cpFirst = selCur.cpLim = selCur.cpFirst = cpMinDocument;
        selCur.fForward = true;
        GetInsPtProps(selCur.cpFirst);

#ifdef OURHEAP
        {
        extern int cwInitStorage;
/* save this amount of heap as "100% free" */
/* formerly CalcTot(true) */
        cwInitStorage = cwHeapMac - cwHeapFree;
        cbTot = (cwHeapMac - cwInitStorage) * sizeof(int);
        cbTotQuotient = (cbTot>>1)/100;
        }
#endif

#ifdef STYLES
/* Set up scrap document to have a valid style sheet on start up. */
        (**hpdocdod)[docScrap].docSsht = (**hpdocdod)[docCur].docSsht;
#endif  /* STYLES */

#ifdef INTL /* International version */
     /* if a word document to be converted, save
        it doing conversion. */

                if (fWordDoc == TRUE)
                        {
                          /* save file in write format. */
                        ConvertFromWord();
                        }
#endif  /* International version */

        SetTitle(szT);

#if defined(OLE)
        ObjOpenedDoc(doc);
#endif
        return TRUE;
}
/* end of  F I n i t A r g s  */




#ifdef OURHEAP
CreateHeapI()
{
FGR *pfgr, *pfgrLim;
#ifdef WINBUG
unsigned cb = (unsigned)GlobalCompact((DWORD)0);
#endif

    ibpMax = ibpMaxSmall;
    if (cb > 0x4fff /* about 20K */)
        {
        HANDLE hTemp;
        /* we can start with a bigger page buffer */
        vcbMemTotal = (unsigned)LocalCompact((WORD)0);
        pmemStart = (CHAR *)LocalAlloc(LPTR, vcbMemTotal);
        /* get all we have and force a reallocation */
        hTemp = LocalReAlloc((HANDLE)pmemStart, 0x4fff, LPTR);
        if (hTemp != NULL)
            {
            LocalFree(hTemp);
            ibpMax = ibpMaxBig;
            }
        else
            {
            /* somehow we failed and went back to the small system */
            LocalFree((HANDLE)pmemStart);
            }
        }

    vcbMemTotal = (unsigned)LocalCompact((WORD)0);

/* memory always bumped to point to the next available slot
   for allocation */
/* take all the space as one chunk and do our own memory management */
    pmemStart = (CHAR *)LocalAlloc(LPTR, vcbMemTotal);
    memory = (int *)pmemStart;
    vcbMemTotal = (unsigned)LocalSize((HANDLE)pmemStart); /* in case
                  we got more than we asked */
    pmemMax = (int *)((CHAR *)memory + vcbMemTotal);

/* take half of heap space for page buffers
    ibpMax = (vcbMemTotal>>1)/cbSector;*/
    iibpHashMax = ibpMax * 2 + 1;

/* Set finger table to low end of heap */
    rgfgr = (PFGR)memory;
    memory += ifgrInit;
    memory = (int *)(((unsigned) memory + 1) & ~1); /* word boundary */

/* Here is our heap */
    pHeapFirst = (int *)memory;

    cwHeapMac = /* cwtotal */
                (((unsigned)pmemMax - (unsigned)pHeapFirst +
                sizeof(int) - 1) / sizeof(int)) -
                /* cw in rgibpHash */
                ((iibpHashMax * sizeof(CHAR) +
                sizeof(int) - 1) / sizeof(int)) -
                /* cw in mpibpbps  */
                ((ibpMax * sizeof(struct BPS) +
                sizeof(int) - 1) / sizeof(int)) -
                /* cw in rgbp */
                ((ibpMax * cbSector * sizeof(CHAR) +
                sizeof(int) - 1) / sizeof(int));

    memory += cwHeapMac;

#ifdef DEBUG
    cwHeapMac -= 16; /* Need spare words for shaking */
                     /* This space is above the finger table */
#endif
    cwHeapFree = cwHeapMac;
    phhMac = (HH *)(pHeapFirst + cwHeapMac);
/* if DEBUG, then phhMac will point at the shake word;
   otherwise it will point to 1 cell after the heap */

    phhFree = (HH *) pHeapFirst;
    phhFree->cw = -cwHeapMac; /* whobj.heap is free */
    phhFree->phhNext = phhFree;
    phhFree->phhPrev = phhFree;

    pfgrMac = &rgfgr[ifgrInit];
    pfgrLim = pfgrMac - 1;

/* thread the free fingers */
    for (pfgr = rgfgr; pfgr < pfgrLim; pfgr++)
        *pfgr = (FGR)(pfgr + 1);
    *pfgrLim = NULL;              /* last free finger */
    pfgrFree = rgfgr;
}
/* end of  C r e a t e H e a p I  */
#endif /* OURHEAP */



STATIC int NEAR FInitDocs()
{ /* Initialize hpdocdod */
        struct DOD *pdod, *pdodLim;
        hpdocdod = (struct DOD (**)[])HAllocate(cwDOD * (docMac = cdocInit));
        if (FNoHeap(hpdocdod))
            return FALSE;

    pdod = &(**hpdocdod)[0];
        pdodLim = pdod + cdocInit;
        while (pdod < pdodLim)
            pdod++->hpctb = 0;  /* Mark all doc entries as free */
        docScrap = DocCreate(fnNil, HszCreate((PCH)""), dtyBuffer);   /* HM */

//Win3.1J
#if defined(JAPAN) & defined(DBCS_IME) /* Doc for Insert IR_STRING from IME */
        docIRString = DocCreate(fnNil, HszCreate((PCH)""), dtyBuffer); /* HM */
#endif

        docUndo = DocCreate(fnNil, HszCreate((PCH)""), dtyBuffer);    /* HM */
#ifdef CASHMERE
        docBuffer = DocCreate(fnNil, HszCreate((PCH)""), dtyBuffer);    /* HM */
#endif

        docCur = docNil;
        NoUndo();
        hszSearch = HszCreate((PCH)""); /* No initial search string */
        hszReplace = HszCreate((PCH)""); /* No initial replace string */
        hszFlatSearch = HszCreate((PCH)""); /* No initial flattenned search string */
        if (docScrap == docNil || docUndo == docNil ||
#if defined(JAPAN) & defined(DBCS_IME) /* Doc for Insert IR_STRING from IME */
        docIRString == docNil ||
#endif
#ifdef CASHMERE
            docBuffer == docNil ||
#endif
            FNoHeap(hszFlatSearch))
                return FALSE;
        return TRUE;
}
/* end of  F I n i t D o c s  */




#ifdef CASHMERE     /* No glossary in MEMO */
FInitBufs()
{
/* Initializes structures and data used in named buffer management.
Allocates space for hgtxb, initializes itxbMac */

        struct TXB *ptxb;
        extern struct TXB (**hgtxb)[];
        extern short itxbMac;

        if (FNoHeap(hszGlosFile = HszCreate((PCH)"")))
            return FALSE;
        if (FNoHeap(hgtxb = (struct TXB (**)[])HAllocate(cwTxb)))
            return FALSE;
        ptxb = &(**hgtxb)[0];
        ptxb->hszName = hszNil;
        itxbMac = 0;
        return TRUE;
}
/* end of  F I n i t B u f s  */
#endif  /* CASHMERE */



STATIC int NEAR FInitProps()
{ /* Initialize your basic properties */

#ifndef FIXED_PAGE
        unsigned dxaRightMin;
        unsigned dyaBottomMin;
#endif /* not FIXED_PAGE */

        vchpNormal.hps = hpsNormal;     /* NOTE - this is the size we use for
                                           incremental encoding, the "default"
                                           size may differ */
        vchpNormal.ftc = 0; /* will be whatever the standard modern font is */
        vchpNormal.ftcXtra = 0;

        vchpNormal.fStyled = true;
        /* vchpNormal.stc = stcNormal; */

        vppapNormal = (struct PAP *)rgwPapNormal;

        /* vppapNormal->fStyled = false; */
        /* vppapNormal->stc = 0; */
        vppapNormal->stcNormChp = stcParaMin;
        /* vppapNormal->dxaRight = 0; */
        /* vppapNormal->dxaLeft = 0; */
        /* vppapNormal->dxaLeft1 = 0; */
        /* vppapNormal->jc = jcLeft; */
        /* vppapNormal->dyaBefore = 0; */
        /* vppapNormal->dtaAfter = 0; */

        vppapNormal->fStyled = true;
        vppapNormal->stc = stcParaMin;
        vppapNormal->dyaLine = czaLine;

        Assert(cwPAP == cwSEP);

        /* vsepNormal.fStyled = false; */
        /* vsepNormal.stc = 0; */
        vsepNormal.bkc = bkcPage;
        /* vsepNormal.nfcPgn = nfcArabic; */

#ifdef FIXED_PAGE
        /* The "normal" page size is fixed at 8-1/2 by 11 inches. */
        vsepNormal.xaMac = cxaInch * 8 + cxaInch / 2;
        vsepNormal.xaLeft = cxaInch * 1 + cxaInch / 4;
        vsepNormal.dxaText = cxaInch * 6;
        vsepNormal.yaMac = cyaInch * 11;
        vsepNormal.yaTop = cyaInch * 1;
        vsepNormal.dyaText = cyaInch * 9;
        vsepNormal.yaRH1 = cyaInch * 3 / 4;
        vsepNormal.yaRH2 = cyaInch * 10 + cyaInch / 4;
#else /* not FIXED_PAGE */
        /* The page size is determined by inquiring it from the printer.  Then,
        other measurements can be derived from it. */
        Assert(vhDCPrinter);
        if (vfPrinterValid && vhDCPrinter != NULL)
            {
            POINT pt;

            /* Get the page size of the printer. */
            if (Escape(vhDCPrinter, GETPHYSPAGESIZE, 0, (LPSTR)NULL,
              (LPSTR)&pt))
                {
                vsepNormal.xaMac = MultDiv(pt.x, dxaPrPage, dxpPrPage);
                vsepNormal.yaMac = MultDiv(pt.y, dyaPrPage, dypPrPage);
                }
            else
                {
                /* The printer won't tell us it page size; we'll have to settle
                for the printable area. */
                vsepNormal.xaMac = ZaFromMm(GetDeviceCaps(vhDCPrinter,
                  HORZSIZE));
                vsepNormal.yaMac = ZaFromMm(GetDeviceCaps(vhDCPrinter,
                  VERTSIZE));
                }

            /* The page size cannot be smaller than the printable area. */
            if (vsepNormal.xaMac < dxaPrPage)
                {
                vsepNormal.xaMac = dxaPrPage;
                }
            if (vsepNormal.yaMac < dyaPrPage)
                {
                vsepNormal.yaMac = dyaPrPage;
                }

            /* Determine the offset of the printable area on the page. */
            if (Escape(vhDCPrinter, GETPRINTINGOFFSET, 0, (LPSTR)NULL,
              (LPSTR)&pt))
                {
                dxaPrOffset = MultDiv(pt.x, dxaPrPage, dxpPrPage);
                dyaPrOffset = MultDiv(pt.y, dyaPrPage, dypPrPage);
                }
            else
                {
                /* The printer won't tell us what the offset is; assume the
                printable area is centered on the page. */
                dxaPrOffset = (vsepNormal.xaMac - dxaPrPage) >> 1;
                dyaPrOffset = (vsepNormal.yaMac - dyaPrPage) >> 1;
                }

            /* Determine the minimum margins. */
            dxaRightMin = imax(0, vsepNormal.xaMac - dxaPrOffset - dxaPrPage);
            dyaBottomMin = imax(0, vsepNormal.yaMac - dyaPrOffset - dyaPrPage);
            }
        else
            {
            /* We have no printer; so, the page is 8-1/2" by 11" for now. */
            vsepNormal.xaMac = 8 * czaInch + czaInch / 2;
            vsepNormal.yaMac = 11 * czaInch;

            /* Assume the entire page can be printed. */
            dxaPrOffset = dyaPrOffset = dxaRightMin = dyaBottomMin = 0;
            }

        /* Ensure that the "normal" margins are larger than the minimum. */
        vsepNormal.xaLeft = umax(cxaInch * 1 + cxaInch / 4, dxaPrOffset);
        vsepNormal.dxaText = vsepNormal.xaMac - vsepNormal.xaLeft - umax(cxaInch
          * 1 + cxaInch / 4, dxaRightMin);
        vsepNormal.yaTop = umax(cyaInch * 1, dyaPrOffset);
        vsepNormal.dyaText = vsepNormal.yaMac - vsepNormal.yaTop - umax(cyaInch
          * 1, dyaBottomMin);

        /* Position the running-heads and the page numbers. */
        vsepNormal.yaRH1 = umax(cyaInch * 3 / 4, dyaPrOffset);
        vsepNormal.yaRH2 = vsepNormal.yaMac - umax(cyaInch * 3 / 4,
          dyaBottomMin);
        vsepNormal.xaPgn = vsepNormal.xaMac - umax(cxaInch * 1 + cxaInch / 4,
          dxaRightMin);
        vsepNormal.yaPgn = umax(cyaInch * 3 / 4, dyaPrOffset);
#endif /* not FIXED_PAGE */

        vsepNormal.pgnStart = pgnNil;
        /* vsepNormal.fAutoPgn = false; */
        /* vsepNormal.fEndFtns = false; */
        vsepNormal.cColumns = 1;
        vsepNormal.dxaColumns = cxaInch / 2;
        /* vsepNormal.dxaGutter = 0; */

        vdxaPaper = vsepNormal.xaMac;
        vdyaPaper = vsepNormal.yaMac;

        vfli.doc = docNil;      /* Invalidate vfli */
        ichpMacFormat = ichpMacInitFormat;
        vhgchpFormat = (struct CHP (**)[])HAllocate(ichpMacInitFormat * cwCHP);
        if (FNoHeap(vhgchpFormat))
            {
            return FALSE;
            }
        return TRUE;
}
/* end of  F I n i t P r o p s  */





STATIC int NEAR FInitFiles()
{
        extern WORD vwDosVersion;

        int fn;
        int cchT;
        struct FKP *pfkp;
        struct FCB *pfcb;
        int osfnExtra;
        CHAR sz [cchMaxFile];

        rfnMac = rfnMacEdit;

        /* Set DOS version we're running under */

        vwDosVersion = WDosVersion();

        InitBps();

#ifdef CKSM
#ifdef DEBUG
        {
        extern int ibpMax, ibpCksmMax;
        extern unsigned (**hpibpcksm) [];

        hpibpcksm = (unsigned (**) [])HAllocate( ibpMax );
        if (FNoHeap( hpibpcksm ))
            return FALSE;
        ibpCksmMax = ibpMax;
        }
#endif
#endif

            /* sz <-- name of new, unique file which will be fnScratch */
        sz[ 0 ] = '\0';     /* Create it in the root on a temp drive */
        if ((fn=FnCreateSz( sz, cpNil, dtyNetwork )) == fnNil )
                /* Couldn't create scratch file: fail */
            return FALSE;

        Assert(fn == fnScratch); /* fnScratch hardwired to 0 for efficiency */
        FreezeHp();
        pfcb = &(**hpfnfcb)[fnScratch];
        pfcb->fFormatted = true; /* Sort of a formatted file */
        pfcb->fDelete = true; /* Kill this file when we quit */
        MeltHp();
        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;

        /* The following can really be allocated 0 words, but why push our luck? */
        vfkpdParaIns.hgbte = (struct BTE (**)[]) HAllocate(cwBTE);
        vfkpdCharIns.hgbte = (struct BTE (**)[]) HAllocate(cwBTE);
        vfkpdParaIns.ibteMac = vfkpdCharIns.ibteMac = 0;
        if (FNoHeap(vfkpdParaIns.hgbte) || FNoHeap(vfkpdCharIns.hgbte))
                return FALSE;

        blt(&vchpNormal, &vchpInsert, cwCHP);
        blt(&vchpNormal, &vchpSel, cwCHP);
        blt(vppapNormal, &vpapPrevIns, cwPAPBase + cwTBD);
        return TRUE;
}
/* end of   F I n i t F i l e s  */




InitBps()
{
/* called from initfiles to set up the tables */
        int ibp, iibp;
        int rfn;
        int fn;

/* In order impliment a LRU page swap strategy, a time stamp(TS) scheme is */
/* used. Associated with each buffer slot is a time stamp.  The least */
/* recently used slot is found by locating the slot with the smallest time */
/* stamp. Every time a new page is brought into the buffer, it TS is set  */
/* equal to the value of a incrimented global TS counter (tsMru...). */
/* Initially, the time stamps are set so that they increase as we move */
/* toward the end of the table.  Thus, even though the entire buffer pool */
/* is initially empty, slots at the beginning of the table will be */
/* allocated first.  */

        {
        register struct ERFN *perfn = &dnrfn [0];

        for (rfn = 0; rfn < rfnMac; rfn++, perfn++)
                {
                perfn->fn = fnNil;
                perfn->ts = rfn;
                }
        tsMruRfn = rfnMac /* + ? */;
        }

        for (iibp = 0; iibp < iibpHashMax; iibp++)
                rgibpHash[iibp] = ibpNil;
        {
        register struct BPS *pbps=&mpibpbps [0];

        for (ibp = 0; ibp < ibpMax; ++ibp, pbps++)
                {
                pbps->fn = fnNil;
                pbps->fDirty = false;
                pbps->ts = ibp;
                pbps->ibpHashNext = ibpNil;
                }
        tsMruBps = ibpMax + cbpMustKeep;
        }
        /* In IbpEnsureValid (file.c) we may not want to use the least */
        /* recently used slot for certain reasons.  But, we do want to */
        /* be assured that we do not clobber the 'cbpMustKeep' most */
        /* recently used slots.  Our check consists of making sure */
        /* (tsMruBps - ts_in_question) < cbpMustKeep.  By the above */
        /* statement, we are assured that non of the empty slots satisfy */
        /* this condition. */

        /* Allocate initial checksum array */



}
/* end of  I n i t B p s  */



#ifdef OURHEAP
FCreateRgbp()
{
    rgbp = (CHAR (*)[cbSector])memory;
    memory = (int *)((unsigned)memory + (unsigned)(ibpMax)
             * cbSector);
    memory = (int *)(((unsigned) memory + 1) & ~1); /* word boundary */
    rgibpHash = (CHAR *)memory;
    memory = (int *)((unsigned)memory +
             (unsigned)(iibpHashMax * sizeof(CHAR)));
    memory = (int *)(((unsigned) memory + 1) & ~1); /* word boundary */
    mpibpbps = (struct BPS *)memory;
    memory = (int *)((unsigned)memory +
             (unsigned)(ibpMax * sizeof(struct BPS)));
    memory = (int *)(((unsigned) memory + 1) & ~1);
    return (memory <= pmemMax);
}
/* end of  F C r e a t e R g b p  */
#else /* use windows' memory manager */
FCreateRgbp()
{
extern int vfLargeSys;

long lcbFree;
unsigned cb;

    ibpMax = ibpMaxSmall;
    lcbFree = GlobalCompact((DWORD)0);
    if (lcbFree > 0x00030D40 /* 200K */)
        {
        /* we can start with a bigger page buffer */
        ibpMax = ibpMaxBig;
        vfLargeSys = TRUE;
        }

    iibpHashMax = ibpMax * 2 + 1;

    cb = ((ibpMax * cbSector * sizeof(CHAR) + 1) & ~1) /* rgbp */
         + ((iibpHashMax * sizeof(CHAR) + 1) & ~1) /* rgibpHash */
         + ((ibpMax * sizeof(struct BPS) + 1) & ~1); /* mpibpbps */

    memory = (int *)LocalAlloc(LPTR, cb);

    if (memory == NULL)
        {
        ibpMax = ibpMaxSmall;
        iibpHashMax = ibpMax * 2 + 1;
        cb = ((ibpMax * cbSector * sizeof(CHAR) + 1) & ~1) /* rgbp */
             + ((iibpHashMax * sizeof(CHAR) + 1) & ~1) /* rgibpHash */
             + ((ibpMax * sizeof(struct BPS) + 1) & ~1); /* mpibpbps */
        memory = (int *)LocalAlloc(LPTR, cb);
        }

    if (memory == NULL)
        return FALSE;

    rgbp = (CHAR (*)[cbSector])memory;
    memory = (int *)((unsigned)memory + (unsigned)(ibpMax)
             * cbSector);
    memory = (int *)(((unsigned) memory + 1) & ~1); /* word boundary */
    rgibpHash = (CHAR *)memory;
    memory = (int *)((unsigned)memory +
             (unsigned)(iibpHashMax * sizeof(CHAR)));
    memory = (int *)(((unsigned) memory + 1) & ~1); /* word boundary */
    mpibpbps = (struct BPS *)memory;

/*
    memory = (int *)((unsigned)memory +
             (unsigned)(ibpMax * sizeof(struct BPS)));
    memory = (int *)(((unsigned) memory + 1) & ~1);*/

    return TRUE;
}
#endif