Page Numbers: Yes X: 530 Y: 10.5" First Page: 23
Margins: Top: 1.3" Bottom: 1"
Heading:
Internal Description of MidasEdward R. Fiala26 November 1979
External Procedures and Statics by File
MIDAS.BCPL (resident)
NMidas(LayoutVector,userParams,CFA)
Starting address of Midas. Calls StartTimer to begin timing the initialization, then calls Init0 in MInit0.Bcpl to begin initialization.
During initialization many timing statics in Midas.Bcpl are filled in to reveal where time is being spent during initialization; they can be looked at with Swat.
InitRes(SlashI)
Entered by a GotoLabel from the Init0A procedure in MInit0.Bcpl. SlashI is true on Midas/i initialization, else false.
On Midas/i, the Init1 procedure is called to do a full initialization; then the Midas.Midas command file is executed to load address symbols and setup two initial display configurations: the display configurations are written on the Midas.RunProg and Midas.Dtach state files under control of the command file. The WriteState action writes the state files.
When SlashI is false, the initialization that would have been done by Init1, etc. is instead carried out by rolling in the Midas.Dtach state file with RestoreState.
Init2 is called to do the final initialization and parse Com.Cm. It calls InitHardware to do the machine-dependent part of this initialization. The command-file named in Com.Cm or on the command line for RunProg, if any, is opened and the stream returned; InitRes then calls CmdDoRC to execute the command file.
RestoreState is also called on RunProg and Dtach to reinitialize Midas prior to executing a command file. RestoreState exits with GotoLabel to the "Resume" tag in InitRes.
Command file execution jumps to the "BegCF" label in InitRes which pushes the current command file on the command file stack and begins execution of the new one; when the new command file finishes and returns, InitRes pops the command file stack, reopens and positions the previous command file and resumes it.
When the command file stack becomes empty, DriverLoop is called (the main loop of Midas) and runs until exit.
StartTimer()
Stores the timer in TimeStart and sets the TimerGoing static true. StartTimer() is called at the onset of Midas initialization, and at the onset of the first command file (in a possibly nested sequence).
ElapsedTime(lv Location)
Put the low-order elapsed time since TimeStart into Location; return the high-order elapsed time (which is 0 for times less than about 65 sec) as the result.
PrintTime(V)
Prints the double-precision vector V as an elapsed time on TimeStream rounded to 100ths of a second.
MidasFinish()
Procedure invoked by bcpl finish prior to exiting Midas. It calls FinishHardware() to do the machine-dependent part of the finish.
MidasSwat(ErrNo,p1,p2,p3,p4,p5)
Does a #77403 swat call with ErrNo as the number of a message in the file "Midas.Errors"; p1 to p5 are parameters used by the Swat error-printing procedure.
lvFinishProc
holds the value of rv lvUserFinishProc when Midas entered (written by Init2, read by MidasFinish).
Initialized
True if Midas initialization has completed (signals that the Get... and Put... procedures will deliver valid data; set true immediately after InitHardware in xxI2.Bcpl has finished initializing the hardware).
BBblockSize
The size of the display bit buffers, a complicated function of the screen size and the font computed by Init0. The value of this static is needed before its value is computed. Hence, the value is compiled into Midas and used during early initialization; later the compiled-in value is checked against the computed value, and Swat is called if there is disagreement. The user can fix the compiled-in value and try again, if this happens. This will happen when ScreenHeight or ScreenWidth changes.
AvailBlockSize
The size of the subpart of BBblockSize used to form an OverlayZone.
TopFrame
Points at the top stack frame which is the InitRes procedure; used by GotoLabel calls on RunProg, Dtach, and RdCmds actions.
SysZoneSize
Size of sysZone, used by MInit0.Bcpl.
StackSize
Size of stack, used by MInit0.Bcpl.
StateFileSize
Size of Midas.Dtach and Midas.RunProg, filled in for statistical purposes.
MINIT0.BCPL (first initialization--code flushed after execution)
Init0(Layout,userParams,CFA)
Puts information in the Layout vector passed by the Exec into FirstStatic, LastStatic, NStatics, RelocTable, Switch (/I), and MidasCFA; converts self-relative pointers in ActionBlock, MEMNAM, and REGNAM to regular vectors, and Junta’s to levStreams to the Init0A procedure.
Init0A()
Initializes the stack, sysZone, and storage area (Storage and EndStorage statics); calls CreateKeyboardStream; then does a GotoLabel to InitRes in Midas.Bcpl to continue initialization.
Init0B(CFA,Switch)
Called from MInit1.Bcpl. Allocates big blocks of storage not saved on the state file. Looks up file FP’s needed by Midas using LookUpEntries, forcing /I initialization if any of these don’t exist. Calls InitHardware1 to do machine-dependent initialization (should load special Alto microcode, if any, using LoadRAM package and allocate any big blocks of storage not wanted on the state file). Does all initialization reasonable before testing for /I, including building bit buffers and DCB’s and allocating storage items that don’t change after initialization. On Midas/I does full init (calls OverlayScan, creates any Midas files that don’t exist on the disk (Midas.Symtab or Swatee, Midas.Fixups, Midas.Compare, etc.) reads Midas.Programs and Midas.UserPrograms and builds table of FP’s and menu for RunProg and RdCmds actions) and returns; otherwise, exits using RestoreState. The Init0 code is flushed after execution.
BlockStoreFPFP for SWATEE (Alphabetically sorted symbol table)
FixUpFPFP for Midas.Fixups (temporary file during loading)
ErrsFPFP for Midas.Compare (output of Compare action)
RunProgFPFP for Midas.RunProg state file
DtachFPFP for Midas.Dtach state file
CopyTemplate()
Bogus routine needed by levStreams.
@MBlock
zrel static filled in with pointer to OS MoveBlock procedure.
Storage
Points at the smallest address in the storage area. Initialization code space is added to the storage area by writing the address of the code being flushed into this static.
EndStorage
Points at the largest address in the storage area; decreased as storage is allocated.
StateBlock
Points at the storage block in which the location and value of page-zero statics and some other information is written; the first few words in the block are described by the "State" structure in MDecl.D.
StatePtr
Pointer into StateBlock.
StateEnd
?
StateBlockSize
contains an upper-bound on 2 * the number of page-zero statics saved in the state file.
FirstStatic,LastStatic,NStatics
Addresses of first and last statics and number of statics from layout vector.
StateStream
disk stream for reading state file
RelocTable
Points at initialization procedure table left by BLDR; used to fixup initialization procedure statics to CallSwat after code thrown away (The fixup sequence in MInit1.Bcpl is presently commented out because the storage for the fixups was overwritten during the initialization.).
* @ACTS
100-word vector used in different ways by action overlays.
ProgramStream
Stream for the left part of the status line.
TimeStream
Stream for the right part of the status line (only written by PrintTime in Midas.Bcpl).
MStatus
Vector which holds information saved across RunProg and Dtach actions.
FirstNonOvLine,NNonOvBitBuffers,FirstLCB
Other items initialized for MDisp.Bcpl.
CmdCS0Vec
Pointer to the TextVec for CmdCommentStream.
CmdCS1Vec
Pointer to the TextVec for CmdCS1.
MINIT1.BCPL(second initialization--only called on Midas/I)
Init1()
Continues initialization begun by Init0. Calls Init0B which returns only on Midas/I. Then, initializes all display regions, symbol table, and EveryTimeList. Enters the registers and memories in the symbol table. Calls InitMPInterface() to build the name-value menus.
NewRegion(blocksize,offset,rlx,rcx,H,W,Type)
returns a new region, with the basic region parameters initialized. blocksize is for the total region including the basic region described as the Rgn structure in MDECL.D. Space is obtained using GetStorage. Arguments are:
blocksizesize of region-description block
offsetnwords from 1st word of block to Rgn structure
rlxline number of 1st line in region (0 is the null region at the top of the display; 1 to ScreenHeight are the display lines.)
rcxleft-most character in region (0 to ScreenWidth-1)
Hnlines in region
Wncharacters wide
Typetype of Rgn (see MDecl.D)
MakeMenuRegion(Size,Letter,LineN,rlx,rcx,H,W,MaxNItems)
creates a menu region of the form given by the MDFS structure in MDecl.D using NewRegion to build the Rgn sub-part of the MDFS structure, where:
SizeSize of the area to be allocated
Letterletter part of menu name for comfiles
LineNline number part of menu name for comfiles
rlx, rcx, H,Wparameters as for NewRegion
MaxNItemsmaximum num menu items
MakeDisplayLine(lvStream,rlx,H,W,rcx)
Creates a text Rgn of height H lines and width W characters beginning at line rlx and character rcx; points Stream at the stream structure for the region; returns a pointer to the TextVec for Stream.
* NewMPDispBlock(L,C,Cnm,W)
must be called to initialize each register display block (see InitMPInterface later)
* GetZStorage(Size)
Allocates a vector of length Size using GetStorage and initializes the body of the vector to 0.
* GetHStorage(Size)
Allocates a vector of length Size+1 using GetStorage and initializes !0 to Size.
MakeTVS(lvStream,lvVector)
Allocates storage for a TextVec of length ScreenWidth and a stream structure using GetStorage; then creates a TV stream. The stream is left in rv lvStream and the vector in rv lvVector.
MakeEmptyTVstream()
Allocates a TV stream without assigning any TextVec to it. Returns a pointer to the stream.
SaveStatics(lvZStatic1,...,lvZStaticN)
Called with up to 20 args. The args are pointers to page zero statics or other program locations which must be saved/restored by SaveState/RestoreState. Non-page-zero statics do not have to be enumerated because they are all saved.
MINIT2.BCPL (Init2 overlay, also invoked by RunProg)
Init2()
Does final display and region initialization, creates the actions for "RunProg" and "RdCmds" menus; on Dtach, calls the machine-dependent DetachHardware procedure to disconnect from the current machine and closes TextCmdOutStream, if it is open; if not Dtach, parses Com.Cm or the input text line in preparation for RdCmds. Calls the machine-dependent InitHardware procedure, which may return an initialization alternate command menu (e.g., to select among several possible machines); puts non-MPD display lines in service; forms the alternate command menu returned by InitHardware, if any, and then the regular command menu; sets Initialized to true; loads as many overlays as possible into unused core; restores CFileStream, CFOutStream, TextCmdOutStream, and ShowActionForm from the MStatus vector. Returns true if RdCmds should be done.
MTXTBUF.BCPL (resident)
ClearInText()
flags input text buffer to go to empty if any new chars are typed; leaves the static TxtBufClearFlag true.
TxtBNewChar(Char)
puts Char into the command line input buffer (This is usually called via the static CharInputRoutine, which also points at TxtBNewChar.)
* InputTextBuffer
a TextVec containing typed in text
* InputStream
Stream for putting characters into InputTextBuffer
MASM.ASM (resident hand-coded procedures)
DummyCall1(lv Proc,NA,A1,A2,...,An)
calls Proc with NA args so that the overlay machinery can intercept the call and return.
DummyCall(lv Proc,A1,A2, ... , An)
calls Proc with n arguments, A1 ... An, so that the overlay machinery can intercept the call and return.
ErrorProtect(lv Proc, A1, A2, ..., An)
establishes an errorset on the stack to which subsequent calls of DisplayError or ErrorExit will return as discussed in the "Errors and Overlays" section earlier; then calls Proc with n arguments, A1, ... An. If OverlayZone is non-existent or empty when ErrorProtect is called, then overlays are flushed before ErrorProtect returns.
* MoveUp(To,From,Count)
moves the block of words of length Count with last location at From to the block whose last location is at To (i.e. like MBlock but starting at the last location of the block).
* SelfRel(X) = X + rv X.
* Mag(X) is the magnitude of X.
* LCycle(X,n) left cycles X by n bits.
* VUsc(V1,V2,Length)
Does an unsigned compare of the DVec’s V1 and V2, which are Length words long. Returns 1 if V1 > V2, -1 if V1 < V2, or 0 if V1 eq V2.
* DoubleNeg(Vec) negates the double-precision vector Vec.
DoubleDiv(Vec,Divs) does unsigned divide of double-precision Vec by single-precision divisor Divs; leaves quotient in Vec; returns remainder as the result.
* Wss(S,str) Outputs the string str onto the stream S.
RepPuts(Stream,Char,Count) Does Puts(Stream,Char) Count times
* @WssCSS(str) Wss(CmdCommentStream,str)
* PutsCSS(C) Puts(CmdCommentStream,C)
* ResetsCSS() Resets(CmdCommentStream)
* WssCS1(str) Wss(CmdCS1,str)
* PutsCS1(C) Puts(CmdCS1,C)
* ResetsCS1() Resets(CmdCS1)
ResetTVs(S,TV,N,NoteP,Arg)
is called by Resets(S,...) when S is a TV stream. Possible calls are:
Resets(S)
does TV!0 = 0 using previously-declared TV for the stream.
Resets(S,TV,N)
binds the stream to TV of length N and TV!0 = 0.
Resets(S,TV,N,NoteP,Arg)
binds the stream to TV of length N and arranges to call NoteP(Arg) whenever the stream is written.
PutTVs(S,Char)
is called by Puts for TV streams created during initialization. PutTVs optionally executes another procedure, which is MarkRgnDispDirty for some of the streams (see ResetTVs in MTV.BCPL).
PaintItem(rlx,TV,charX)
is called by MarkMenus to paint a menu item into ScreenTV. TV is a TextVec containing the menu item, rlx and charX are the relative line number and character position of the first character of the item in the region. The parameters of the region were previously established by a call to PaintBase.
VertIntCode() Vertical interrupt routine initialized in MDisp.Bcpl.
ClearAndScanConvert(BitBuffer,String)
used by MDISP to fill BitBuffer from font characters for String.
StrSize(StrPtr) = length of the string in words.
SearchBlock(Block,Boffset,Bname,Addr,MemX)
is a subroutine which searches Block for the address in MemX whose value is the largest less than or equal to Addr (see MSYM).
SymbKeyComp(Str1,Str2)
compares the two strings returning 0 on equal, positive on Str1 >= Str2, negative on Str1 < Str2.
BinScan(Block,Key)
returns the index of the greatest record in Block with key le Key.
GetBodySize Another subroutine for MSYM.
* GetField(Bit1,NBits,DVec)
Returns the contents of the named field right-justified.
* PutField(Bit1,NBits,DVec,Field)
Copies NBits from Field (right-justified word) to a position in DVec, starting with Bit number Bit1, where the bits are numbered starting from 0. NBits must be le 16.
* MoveLongField(Source,SBit1,NBits,Dest,DBit1)
Moves NBits from the Source DVec to the Dest DVec where the left-most bit in Source is SBit1 and the left-most bit in Dest is DBit1.
PutTxts,ResetTxts
Implement the Puts and Resets stream procedures for display lines (CmdCommentStream, CmdCS1, ProgramStream, and TimeStream). These procedures are invoked by Puts and Resets rather than by direct calls.
BackUp(Stream)
Wait(N)
Idles for 100*N microseconds (N must be > 0)
* @OddParity(X,Y)
Returns true if the number of 1’s in (X xor Y) is odd, else false.
* GetStorage(Size)
returns pointer to permanent block of size Size, or calls Swat if not enough space.
* GetEvenStorage(Size)
returns pointer to block of size Size which starts on an even address.
MaskT
Points 1 before the OS table used by Convert; table entry MaskT!n contains 2n-1 (i.e., right-justified mask of n bits).
@AbortLabel, @AbortFrame
Statics used by ErrorProtect and DisplayError
@BlockTable
Points at table of pointers to symbol Blocks.
@MSave2,@Count
ZRel statics available for temporary storage by hand-coded procedures.
MDATA.ASM (resident data inappropriate for allocation by GetStorage)
MidasCFA
The CFA for Midas.Run passed to Midas via CallSubsys.
TimeStart is a double-precision vector written with Timer() by StartTimer()
* GoVec is an 8-word vector used by MGo.Bcpl
LastTimer is a double-precision vector used by ElapsedTime(..) in Midas.Bcpl.
TimeTimeOut is a double-precision vector used by the time-out stuff.
BadAText is the default error string for ErrorExit()
MDATAtab
the vector holding the contents of the MDATA memory; this includes a number of vectors of size TValSize used by the "Test" stuff (and may include some machine-dependent stuff too).
@BitsChecked,@ShouldBe,@DataWas,BitsPicked,BitsDropped
Vectors in MDATAtab corresponding to displayable addresses in the MDATA memory.
MADDRtab
the vector holding the contents of the MADDR memory; this includes a number of vectors of length 2 used by the "Test" stuff and may include error counters and other machine-dependent stuff as well).
@LowAddress,@HighAddress,@LoopCount,@CurrentAddress,@AddrIncrement
DWatch,AddrIntersect,AddrUnion,TestFailures
Vectors in MADDRtab with corresponding displayable addresses in the MADDR memory.
MSYM.BCPL (resident--symbol table and parsing)
EvalAText(TV,lvX,AVal,ifExpectMore,SName)
will return true if the text starting at TV!(rv lvX) has the form of a memory name (optional Offset), register name, or address (optional +/- Offset), and, unless ifExpectMore, is not followed by more text. SName (optional, defaulted to DefMemName) is the default memory name, used if the first term in TV is a pure number rather than a symbol. The optional Offset may be any expression consisting of integers and address symbols connected by "+" or "-"; this expression is evaluated using the default radix for the memory (obtained from MEMCON).
In the case of a true return, AVal (see AVal structure in MDecl.D) is filled with information describing the address; rv lvX is adjusted to point to the next field, after being stepped over one character (assumed to be an appropriate separator).
SkipBlankToken(TV,lvX)
advances rv lvX past leading blanks starting at TV!(rv lvX).
ChkToken(TV,lvX,lvSize)
Begins parsing at the (rv lvX)th item in TV. It advances rv lvX past leading blanks, parses the token following that, leaving the size in rv lvSize, and returns the kind of token as its result. The tokens returned are given in a manifest in MDecl.D. These are arranged so that numbers of varying radices can easily be distinguished.
StreamFromTextName(TV,DotExt,ksType,ItemSize)
Parses a file name in TV, defaulting the extension to the string DotExt; then calls QuickOpenFile. Returns the stream on success, else calls ErrorExit()
QuickOpenFile(Name,ksType,Item)
searches the table of file DV’s built from Midas.Programs and Midas.UserPrograms and opens a stream using CreateDiskStream, if Name is found in the table or using OpenFile, if it is not.
TVtoString(TV)
returns a string with same contents as the textvec TV. Only one such string may exist at a time. (They are stored in a fixed vector @StringVec) useful for making entries in symbol table.
* SearchBlocks(S,MemX,AVec,IMA,MemNameP,Radix)
searches all symbol blocks for the address symbol in MemX whose value is the largest le AVec (currently limited to MemX’s that have single-precision AVec’s). Optional IMA arg causes ".-3" to ".+3" to be printed if no symbol exactly equals AVec and if AVec!1 is within 3 of IMA. Otherwise, the symbol is printed on the stream S followed by the displacement "+n". If the optional arg MemNameP is omitted or true, AVec is printed as "memname val" when no address symbols are in the table, else just as "val". Radix controls numerical printout.
Before searching all the symbol blocks, the machine-dependent procedure FastSearch(Addr,MemX) is called; FastSearch may return the BlockTable index of a block known to contain the best symbol, thereby reducing compute time.
MapSymBlocks(Proc,Strategy,A1,A2,A3,A4)
Mapping procedure to apply Proc(B,A1,A2,A3,A4) to each of the symbol blocks, where B is a pointer to the BT structure for the symbol block (in BlockTable). When blocks need to be read from the disk, the Strategy argument is used in the call to GetBlock. MapSymBlocks is primarily for use by SearchBlocks, but machine-dependent code may use it to build inverted tables for FastSearch.
FindInTable(Key,Body,lv BodySize)
attempts to find a table entry. Returns true if succeeded. Key is a pointer to a bcpl string. Body is place where result record will be placed. BodySize will contain actual size of body.
GetBlock(BlockAddr,Kind,Strategy,Block)
Ensures that the record file block with index BlockAddr is in core, swapping from the disk if necessary. Returns a pointer to the BT descriptor for the block. If BlockAddr is not in core, FindFreeBlock(Block,Strategy) is called to pick an in-core block for replacement; the block selected will have a core address different from Block (which should be 0 if don’t care).
FindFreeBlock(Block,Strategy)
returns the BlockTable index of a free core block different from the one at core address Block using Strategy to select among the contending blocks; calls PutBlock to write the selected block, if it is dirty. Strategy is a small integer selecting the replacement strategy as discussed in the listing.
Map
points at a table of length MaxBlockPages+1 whose entries contain the disk addresses for pages in the record file (or FillInDA); used by GetBlock and PutBlock.
@BHsize contains the size of the BH structure in MDECL.D
@StringVec points at a 129-word vector used by TVtoString.
MSYMOV.BCPL (in Loader overlay)
UpdateRcd(Key,Body,BodySize,nil)
either inserts a new or updates an existing symbol table record.
PutBlock(B)
Writes the block whose BT descriptor is at location B onto the disk.
CleanUpBlocks()
Writes all dirty record file blocks ont the disk.
MIOC.BCPL (resident I/O conversion to/from streams/DataVec’s)
* DWns(S,DVec,NBits,DBit1,Radix,Width,flush0)
Outputs the number contained in a field of a DVec onto a stream S. NBits is the number of bits in the field (default 32); DBit1 the first bit (default 0); Radix is defaulted to 8 (negative radix means print as a signed number); Width (default 1) is the minimum number of characters printed; flush0 controls the fill characters output in front of the number and the handling of a number with value 0: flush0 eq 0 means don’t print anything if the number is 0; flush0 eq $*S means supply leading blanks to fill Width; flush0 eq $0 means print leading 0’s to fill Width. DWns returns flush0 as its result if the number is 0, else it returns $0.
* Wns(S,num,width,radix)
Same as OS but uses DWns (The OS procedure has been Junta’d away).
* SimpleTexttoDVec(TV,Nbits,DVec,Radix)
converts a TextVec into a DataVec of size Nbits. Blanks are flushed. If characters other than octal chars and blanks are in TV, then the text is treated as an an address and offset which is evaluated. Radix is defaulted to 8.
GenlTexttoDVec(TV,Form,DVec,Radix)
parses TV into a sequence of expressions delimited by blanks; matches these expressions right-to-left with corresponding fields in the format vector Form (from MEMFORMS or REGFORMS in xxTables.Asm), evaluates the expressions, and stores the values into the fields of DVec.
* DatatoStream(Stream,Form,Width,DVec,Radix)
format data in DVec and output the text to Stream under control of Form (from MEMFORMS!MemX or REGFORMS!RegX) or use Width (from MEMWID!MemX or REGWID!RegX) if Form is 0. Radix is defaulted to 8.
MOVERLAY.BCPL (resident overlay manager)
@OverlayFaultProc(ac0,ac1, . . .)
intercepts calls to procedures not in core and swaps in the overlay containing the procedure.
ReadOverlay(pn,core,np,od)
reads an overlay; used by OverlayFaultProc and by Init2 (see code for details).
KillOverlays()
will cause all overlays in OverlayZone to be flushed and ReUseDispSpace() to be called (no-op if OverlayZone contains 0).
FlushOverlays()
will cause all overlays in OverlayZone to be flushed, but leaves OverlayZone intact.
PeelOverlay()
Called to remove the top-most overlay to make space for a new symbol block or in preparation for RunProg.
SwappedOut()
Dummy routine needed by BLDR; after initialization, procedure statics in initialization code are bound to this procedure.
OverlayZone
Zone from which overlay space was obtained, can be used for space by the overlay code, so long as all use terminated when overlay flushed**
OverlayFlushed
set true by KillOverlays, false by ReUseDispSpace. Indicates that the bit buffers in AvailBlock have to be rebuilt and OverlayZone destroyed.
OvTable
table of overlay od’s manipulated by overlay loading code in MINIT2 and by PeelOverlay().
MDISP.BCPL(resident display driver)
UpdateDisplay(Z)
The Z arg is passed only for the call from SetDisplay(false); unless this arg is passed, UpdateDisplay will return without doing anything when the display is off. If the display is on or if the Z arg is passed, then PaintDirtyRegions is called to rebuild ScreenTV for text lines. Then GetFreeBitBuffer is called to rebuild bit buffers for all the display lines.
PrepareCharInv(charlocinfont)
is called by ClearAndScanConvert in MAsm.Asm to invert black for white in a font character.
FinishDisplay()
is called from MidasFinish() before returning to the Executive.
* SetDisplay(Flag,nil,nil)
called both directly and as an action; turns off the display if Flag is true, turns it on if Flag is false. Result is previous value of DisplayOff. If the display is being turned on and OverlayFlushed is true, ReUseDispSpace() is called; then UpdateDisplay is called.
* Blink()
will blink the entire display once for about 0.2 sec.
MakeDispZoneAvail()
blanks the part of the screen used for register name-value display, and creates OverlayZone from the bit buffers of that portion of the screen.
ReUseDispSpace()
reverses the effect of MakeDispZoneAvail(). Used only by KillOverlays() in MOverlay.Bcpl and by SetDisplay(false).
VertIntFlag (referenced in MAsm.Asm) indicates that a vertical interrupt has occurred since the flag was set false--used by the bit-buffer management stuff to determine when an old bit buffer can be released.
NwdsPerScanLine
the number of bit-buffer words/scan line
FontCharWidth,LineCtrlBlockPtrsVector
DisplayOff
A predicate that is true when the display is off; it is manipulated by SetDisplay(..)
GACHA10.BR (resident GACHA10.AL font built by the MakeFont program)
FontP
Points at the second word of the font. FontP!-1 contains the font width (fixed pitch) in the right-half. FontP!-2 contains the height of the font in scan lines.