DIRECTORY
Basics,
BasicTime USING [ToPupTime],
Commander,
CommandTool,
Convert USING [Error, CardFromRope],
FS,
IO,
Loader USING [BCDBuildTime],
MessageWindow USING [Append, Blink, Confirm],
PrincOps USING [aLOADRAMJ, zMISC],
PrincOpsUtils USING [LongZero],
RefText,
Rope,
ViewerClasses USING [Viewer],
ViewerIO USING [CreateViewerStreams],
ViewerOps USING [EnumProc, ChangeColumn, EnumerateViewers, FindViewer, OpenIcon],
VM USING [AddressForPageNumber, PagesForWords, SimpleAllocate];

LoadMB: CEDAR MONITOR
IMPORTS
Basics, BasicTime, Commander, CommandTool, Convert, FS, IO, Loader, MessageWindow, PrincOpsUtils, RefText, Rope, ViewerIO, ViewerOps, VM

= BEGIN

ROPE: TYPE = Rope.ROPE;
STREAM: TYPE = IO.STREAM;
Viewer: TYPE = ViewerClasses.Viewer;
tsStream: STREAM;

OneBit: TYPE = [0..1];

CSItem: TYPE = MACHINE DEPENDENT RECORD[
pe020(0: 0..0): OneBit,
rstk0(0: 1..1): OneBit,
pe2131(0: 2..2): OneBit,
blk(0: 3..3): OneBit,
zero(0: 4..4): OneBit _ 0,
blank(0: 5..12): [0..377B] _ 0,		-- unused, leave zero for now
type (0: 13..15): CSItemType,
dataOrEnd (1): SELECT OVERLAID * FROM
data => [
addr (1): WORD,		-- address
word0 (2): WORD,		-- left half (IM, IFUM) or entire value (RM)
word1 (3): WORD		-- right half (IM, IFUM)
],
end => [
endBlank (1): WORD,
checksum (2): INTEGER,		-- checksum over entire item array
startAddr (3): CARDINAL		-- starting address
],
ENDCASE
];

CSItemType: TYPE = MACHINE DEPENDENT {itemIM(0), itemIFUM(1), itemEnd(2), itemRM(3)};

BlockType: TYPE = MACHINE DEPENDENT {
mbEnd(0),		-- end of MB file
mbData(1),		-- store memory data and increment location
mbMemory(2),	-- set memory number and location
mbFixup(3),		-- forward reference fixup
mbMemoryName(4),	-- correlate memory name and number
mbAddress(5),		-- define address symbol
mbUndefined(6)		-- external reference
};

MBHeader: TYPE = BlockType;		-- block type

MBData: TYPE = MACHINE DEPENDENT RECORD[
sourceLine: CARDINAL,		-- source line number
value: CARDINAL			-- left-adjusted data starts here
];

MBMemory: TYPE = MACHINE DEPENDENT RECORD[
memNum: CARDINAL,		-- memory number
location: CARDINAL			-- first location in memory
];

MBFixup: TYPE = MACHINE DEPENDENT RECORD[
memNum: CARDINAL,		-- memory number
location: CARDINAL,			-- location in memory
firstBit: BYTE,				-- field to be stored into
lastBit: BYTE,
value: CARDINAL			-- value to be stored
];

MBMemoryName: TYPE = MACHINE DEPENDENT RECORD[
memoryNum: CARDINAL,		-- memory number
width: CARDINAL				-- memory width
];

MBAddress: TYPE = MACHINE DEPENDENT RECORD[
memNum: CARDINAL,		-- memory number
value: CARDINAL			-- address value
];

MBUndefined: TYPE = MACHINE DEPENDENT RECORD[
memNum: CARDINAL,	-- memory number
location: CARDINAL,		-- location in memory
firstBit: BYTE,			-- field to be stored into
lastBit: BYTE
];

maxMemoryNum: INTEGER = 50;
etherVersionNumber: WORD = 1;  -- *** Change to 1 lshift 8 someday ***
RStkWord: TYPE = MACHINE DEPENDENT RECORD[	-- first word in IM word
SELECT OVERLAID * FROM
r1 => [rstk: [0..17B], aluf: [0..17B], bsel: [0..7B], lc: [0..7B], asel01: [0..3] ],
r2 => [rstk0: OneBit, rest0: [0..77777B] ],
ENDCASE
];

ASelWord: TYPE = MACHINE DEPENDENT RECORD[	-- second word in IM word
SELECT OVERLAID * FROM
a1 => [asel2: OneBit, blk: OneBit, ff: [0..377B], jcn05: [0..77B] ],
a2 => [asel2blk: [0..3], rest1: [0..37777B] ],
ENDCASE
];

IMWord: TYPE = MACHINE DEPENDENT RECORD[		-- IM word, in MB file only
rstk (0):  RStkWord,
asel (1): ASelWord,
jcn67 (2: 0..1): [0..3],
pe020 (2: 2..2): OneBit,
pe2131 (2: 3..3): OneBit,
blank2 (2: 4..15): [0..7777B],
blank3 (3: 0..3): [0..17B],
absoluteAddr (3: 4..15): [0..7777B]
];
 

IFUMWord1: TYPE = MACHINE DEPENDENT RECORD[
sgn (0: 0..0): OneBit,
p0 (0: 1..1): OneBit,		-- only these are referenced
p1 (0: 2..2): OneBit,		-- only these are referenced
p2 (0: 3..3): OneBit,		-- only these are referenced
len (0: 4..5): [0..3],
rbaseB (0: 6..6): OneBit,
memB (0: 7..9): [0..7],
type (0: 10..11): [0..3],
n (0: 12..15): [0..17B]
];

IFUMWord: TYPE = MACHINE DEPENDENT RECORD[
word0: WORD,		-- no internal structure needed
word1: IFUMWord1
];

-- masks defining contribution of each word to each parity bit for IFUMWord
ifumW0P0: WORD = 1400B;
ifumW0P1: WORD = 377B;
ifumW0P2: WORD = 2000B;
ifumW1P0: WORD = 317B;
ifumW1P1: WORD = 0B;
ifumW1P2: WORD = 107460B;

RMWord: TYPE = WORD;		-- RM word, in MB file and in Item

-- * * * * * * * * * * * * * * ** * * * * * * * * * * * * * *


SrcFile: TYPE = REF SrcFileRec;

SrcFileRec: TYPE = RECORD [	-- Input file descriptor
next: SrcFile,
name: ROPE,		-- -> complete file name string
stream: STREAM,
startAddr: CARDINAL _ 177777B		-- microcode starting address for this overlay
];

OutFile: TYPE = REF OutFileRec;
OutFileRec: TYPE = RECORD [
fullName: ROPE,
shortName: ROPE,
stream: STREAM
];

OutputFormat: TYPE = {immediate, brFormat, etherBootable};

EBHeader: TYPE = MACHINE DEPENDENT RECORD[
etherVersionNumber(0): WORD,
mustBeZero(1): INT _ 0,
creationDate(3): LONG CARDINAL,
nameLen(5): INTEGER,
maxNameLen (6): WORD,
nameChars(7): PACKED ARRAY[0..0) OF CHAR
];

ParityWord: TYPE = MACHINE DEPENDENT RECORD[
unused (0: 0..14): [0..77777B],
parity (0: 15..15): OneBit
];

maxItems: INT = 4096+1024+256+1;  -- IM+IFUM+RM+End, enough for one full image
itemArray: LONG POINTER TO WORD _ NIL;
itemLength: CARDINAL = SIZE[CSItem];
itemArrayLength: CARDINAL = maxItems*itemLength;
nextItemAddr: LONG POINTER TO WORD;
scratch: LONG POINTER;		-- will be 256 words long, used for writing EBHeader
ebHeaderLength: INTEGER = 256;

herald: ROPE = "\n  * * * * LoadMB of %g * * * *\n";
textLine: REF TEXT _ NEW[TEXT[RefText.line]];
ItemArrayOverflow: SIGNAL = CODE;

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Main: Commander.CommandProc = {
argV: CommandTool.ArgumentVector _ CommandTool.Parse[cmd];
wDir: ROPE _ CommandTool.CurrentWorkingDirectory[];
outputFormat: OutputFormat _ immediate;
outFile: OutFile;
srcFileChain: SrcFile _ NIL;
lastSrcFile: SrcFile _ NIL;
defaultStartAddress: CARDINAL _ 177777B;
verify: BOOL _ FALSE;
lastFileName: ROPE;
AnotherSrcFile: PROC[name: ROPE] = {
sf: SrcFile _ NEW[SrcFileRec];
sf.name _
CommandTool.FileWithSearchRules[lastFileName, ".mb", cmd, FALSE];
IF srcFileChain = NIL THEN srcFileChain _ lastSrcFile _ sf
ELSE {
lastSrcFile.next _ sf;
lastSrcFile _ sf;
};
};

tsStream _ TSStream["Dorado Microcode"];
tsStream.PutF[herald, IO.time[Loader.BCDBuildTime[LoadMB.Main]]];
IF itemArray = NIL THEN {
itemStartI: LONG POINTER _ VM.AddressForPageNumber[VM.SimpleAllocate[VM.PagesForWords[itemArrayLength]].page];
itemArray _ LOOPHOLE[itemStartI, LONG POINTER TO WORD];
};
TRUSTED { PrincOpsUtils.LongZero[itemArray, itemArrayLength] };
IF scratch = NIL THEN
scratch _ VM.AddressForPageNumber[VM.SimpleAllocate[1].page];

FOR i: NAT IN [1..argV.argc) DO
this: ROPE _ argV[i];
SELECT this.Fetch[0] FROM
IN ['0 .. '9] => {
ok: BOOL _ TRUE;
IF lastFileName = NIL THEN {
tsStream.PutF[
" start pos (%g) must follow source file - quitting\n", IO.rope[this]];
RETURN;
}
ELSE {
AnotherSrcFile[lastFileName];
lastFileName _ NIL;
};
IF lastSrcFile = NIL THEN {
tsStream.PutF[
" start pos (%g) but no source file specified - quitting\n", IO.rope[this]];
RETURN;
};

lastSrcFile.startAddr _ Convert.CardFromRope[this, 8 ! Convert.Error => {
tsStream.PutF[" Conversion error trying %g - quitting\n", IO.rope[this]];
ok _ FALSE;
CONTINUE }; ];
IF ~ok THEN RETURN;
lastFileName _ NIL;
};
'- => {		-- switches
FOR j: INT IN [1..this.Length[]) DO
SELECT this.Fetch[j] FROM
'B, 'b => {
outputFormat _ brFormat;
lastFileName _ NIL;
};
'E, 'e => {
outputFormat _ etherBootable;
lastFileName _ NIL;
};
'O, 'o => {
ext: ROPE _ IF outputFormat = etherBootable THEN ".eb" ELSE ".br";
outFile _ NEW[OutFileRec];
outFile.fullName _ FS.ExpandName[lastFileName, wDir].fullFName;
outFile.shortName _ ShortName[outFile.fullName];
lastFileName _ NIL;
};
'V, 'v => verify _ TRUE;
ENDCASE =>
tsStream.PutF["\n Undefined switch: %g\n", IO.char[this.Fetch[j]] ];
ENDLOOP;
}
ENDCASE	=> {			-- filename
IF lastFileName # NIL THEN AnotherSrcFile[lastFileName];
lastFileName _ this;
};
ENDLOOP;

IF lastFileName # NIL THEN AnotherSrcFile[lastFileName];

IF srcFileChain = NIL THEN {
tsStream.PutRope["\n No input file(s) specified - quitting\n"];
RETURN
};

IF outputFormat = brFormat THEN {
tsStream.PutRope["BR format not supported - quitting\n"];
RETURN;
};
IF outFile = NIL AND outputFormat = etherBootable THEN
OutFileNamesFromSrcFile[outFile _ NEW[OutFileRec], lastSrcFile.name, "eb"];

defaultStartAddress _ 1076B;
DoLoadMb[srcFileChain, outFile, defaultStartAddress, outputFormat, verify];
};

DoLoadMb: PROC[srcFileChain: SrcFile, outFile: OutFile,
				defaultStartAddress: CARDINAL, outputFormat: OutputFormat, verify: BOOL ] = {
totalItems: INT _ 0;
itemsThisFile: INT;
ok: BOOL;

IF outFile # NIL THEN outFile.stream _
FS.StreamOpen[fileName: outFile.fullName, accessOptions: $create, keep: 2];

IF outputFormat = etherBootable THEN WriteEBHeader[outFile];

FOR srcF: SrcFile _ srcFileChain, srcF.next UNTIL srcF = NIL DO
BEGIN
srcF.stream _ FS.StreamOpen[srcF.name ! FS.Error =>
{ tsStream.PutRope[error.explanation]; GOTO cant} ];

tsStream.PutF[" ******* Reading %g\n", IO.rope[srcF.name] ];
[itemsThisFile, ok] _ ReadMBFile[srcF, tsStream];
IF ~ok THEN {
tsStream.PutRope["\n *** Errors encountered - quitting\n"];
srcF.stream.Close[];
IF outFile # NIL AND outFile.stream # NIL THEN outFile.stream.Close[];
RETURN;
};
IF srcF.startAddr = 177777B THEN srcF.startAddr _ defaultStartAddress;
srcF.stream.Close[];
AppendEndItem[nextItemAddr, srcF.startAddr];
totalItems _ totalItems + itemsThisFile + 1;		-- + 1 for endItem
tsStream.PutF["\n %bB items read from %g; starting address = %bB\n",
IO.int[totalItems], IO.rope[srcF.name], IO.int[srcF.startAddr]];

IF outputFormat # immediate THEN TRUSTED {	-- write out the itemArray & re-use
outFile.stream.UnsafePutBlock[
[base: LOOPHOLE[itemArray], startIndex: 0, count: 2*totalItems*itemLength] ];
PrincOpsUtils.LongZero[itemArray, totalItems*itemLength];
};
EXITS
cant => NULL;
END;
ENDLOOP;
IF outFile # NIL AND outFile.stream # NIL THEN {
tsStream.PutF["\n %g bytes written on %g\n",
IO.int[outFile.stream.GetLength[]], IO.rope[outFile.fullName]];
outFile.stream.Close[];
};
tsStream.PutRope["\n\n ~~~~~~~ Finished ~~~~~~~\n"];
IF outputFormat = immediate OR verify THEN {
IF SomethingWorthSaving[] THEN RETURN;
MessageWindow.Blink[];
IF ~MessageWindow.Confirm["Confirm loading new microcode . . . "] THEN {
MessageWindow.Append["boot aborted."];
RETURN
};
LoadRamAndJump[LOOPHOLE[itemArray-1], 1];
};
};

SomethingWorthSaving: PROC RETURNS [BOOL] = {
dirty: BOOL _ FALSE;
CheckDirty: ViewerOps.EnumProc = {
IF v.newVersion OR v.newFile THEN dirty _ TRUE ELSE RETURN;
IF v.offDeskTop THEN ViewerOps.ChangeColumn[v, left];
};
ViewerOps.EnumerateViewers[CheckDirty];
IF dirty THEN {
MessageWindow.Blink[];
IF ~MessageWindow.Confirm["Confirm discard of edits . . . "] THEN {
MessageWindow.Append["boot aborted."];
RETURN[TRUE]
};
};
RETURN[FALSE]
};

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
ReadMBFile: PROC[srcFile: SrcFile, tsStream: STREAM] 
	RETURNS[itemsThisFile: INT, ok: BOOL] = TRUSTED {
memNum: INTEGER _ -1;
addr, addrValue: CARDINAL _ 0;
blockType: BlockType;
memoryWidths: ARRAY [-2 .. maxMemoryNum) OF CARDINAL _ ALL[0];
readStream: STREAM = srcFile.stream;
memoryNumIM, memoryNumIFUM, memoryNumRM: INTEGER _ -2;
nullMemoryNum: INTEGER = -1;
tempI: LONG POINTER _ VM.AddressForPageNumber[VM.SimpleAllocate[1].page];
temp: LONG POINTER TO WORD _ LOOPHOLE[tempI, LONG POINTER TO WORD];

GetBlockTypeFromStrm: PROC[strm: STREAM] RETURNS[BlockType] = TRUSTED {
blk: WORD _ GetWord[strm];
RETURN[LOOPHOLE[blk, BlockType]];
};

itemsThisFile _ 0;
ok _ TRUE;
nextItemAddr _ itemArray;
DO
thisItemLength: INT _ itemLength;
imItem: LONG POINTER TO CSItem;
blockType _ GetBlockTypeFromStrm[readStream];
imItem _ LOOPHOLE[nextItemAddr];

SELECT blockType FROM
mbEnd => RETURN[itemsThisFile, TRUE];

mbData => {
[] _ GetWord[readStream];		-- sourceLine, ignore
IF memNum # nullMemoryNum THEN
FOR i: CARDINAL IN [0..memoryWidths[memNum]) DO
(temp+i)^ _ GetWord[readStream]; ENDLOOP;

SELECT memNum FROM
memoryNumIM => {
mbDataBlock: LONG POINTER TO IMWord = LOOPHOLE[temp];
rstk2Word: r2 RStkWord = LOOPHOLE[mbDataBlock.rstk];
asel1Word: a1 ASelWord = LOOPHOLE[mbDataBlock.asel];
asel2Word: a2 ASelWord = LOOPHOLE[mbDataBlock.asel];
imItem.type _ itemIM;
imItem.addr _ mbDataBlock.absoluteAddr;
imItem.word0 _ (rstk2Word.rest0)*2 + asel1Word.asel2;
imItem.word1 _ (asel2Word.rest1)*4 + mbDataBlock.jcn67;
imItem.pe020 _ mbDataBlock.pe020;
imItem.rstk0 _ rstk2Word.rstk0;
imItem.pe2131 _ mbDataBlock.pe2131;
imItem.blk _ asel1Word.blk;
itemsThisFile _ itemsThisFile + 1;
nextItemAddr _ nextItemAddr + itemLength;
};
memoryNumIFUM => {
ifumDataBlock: LONG POINTER TO IFUMWord = LOOPHOLE[temp];
imItem.type _ itemIFUM;
imItem.addr _ addr;
ifumDataBlock.word1.p0 _
NotOddParity[Basics.BITAND[ifumDataBlock.word0, ifumW0P0],
Basics.BITAND[LOOPHOLE[ifumDataBlock.word1], ifumW1P0] ];
ifumDataBlock.word1.p1 _
NotOddParity[Basics.BITAND[ifumDataBlock.word0, ifumW0P1],
Basics.BITAND[LOOPHOLE[ifumDataBlock.word1], ifumW1P1] ];
ifumDataBlock.word1.p2 _
NotOddParity[Basics.BITAND[ifumDataBlock.word0, ifumW0P2],
Basics.BITAND[LOOPHOLE[ifumDataBlock.word1], ifumW1P2] ];

imItem.word0 _ ifumDataBlock.word0;
imItem.word1 _ LOOPHOLE[ifumDataBlock.word1];
itemsThisFile _ itemsThisFile + 1;
nextItemAddr _ nextItemAddr + itemLength;
addr _ addr + 1;
};
memoryNumRM => {
rmDataBlock: LONG POINTER TO RMWord = LOOPHOLE[temp];
imItem.type _ itemRM;
imItem.addr _ addr;
imItem.word0 _ rmDataBlock^;
itemsThisFile _ itemsThisFile + 1;
nextItemAddr _ nextItemAddr + itemLength;
addr _ addr +1;
};
nullMemoryNum =>
tsStream.PutRope[" *** Data for unspecified memory\n"];
ENDCASE => NULL;
};

mbMemory => {
memNum _ GetInteger[readStream];
IF memoryWidths[memNum] = 0 THEN {
tsStream.PutF["\n *** Undefined memory (%g) - quitting\n", IO.int[memNum]];
RETURN[itemsThisFile, FALSE]
};
addr _ GetInteger[readStream];
};

mbFixup => {
tsStream.PutRope["Fixup block encountered in MB file - quitting\n"];
RETURN[itemsThisFile, FALSE]
};

mbMemoryName => {
newMemoryNum: INTEGER _ GetInteger[readStream];
width: WORD _ GetWord[readStream];
val: WORD _ width + 15;
name: ROPE;
ReadName[readStream, textLine];
IF newMemoryNum > maxMemoryNum THEN {
tsStream.PutF["\nNew MemoryNum (%g) is out of bounds", IO.int[newMemoryNum]];
RETURN[itemsThisFile, FALSE];
};
memoryWidths[newMemoryNum] _ Basics.BITSHIFT[val, -4];
name _ RefText.TrustTextAsRope[textLine];
SELECT TRUE FROM
name.Equal["IM", FALSE] => memoryNumIM _ newMemoryNum;
name.Equal["IFUM", FALSE] => memoryNumIFUM _ newMemoryNum;
name.Equal["RM", FALSE] => memoryNumRM _ newMemoryNum;
ENDCASE =>
tsStream.PutF["\n Other memory name (%g)\n", IO.rope[name]];
};

mbAddress => {
[] _ GetWord[readStream];
[] _ GetWord[readStream];
[] _ ReadName[readStream, textLine];
};

mbUndefined => {
tsStream.PutRope["Undefined symbol block encountered in MB file"];
RETURN[itemsThisFile, FALSE];
};

ENDCASE => {
tsStream.PutF["Unknown block type (%g) in MB file",
IO.card[LOOPHOLE[blockType, CARDINAL]] ];
RETURN[itemsThisFile, FALSE];
};
ENDLOOP;
};

LoadRamAndJump: PROC[itemArray: LONG POINTER, flag: CARDINAL] =
	TRUSTED MACHINE CODE {PrincOps.zMISC, PrincOps.aLOADRAMJ};

NotOddParity: PROC[w1, w2: WORD] RETURNS[notParity: OneBit] = {
OPEN Basics;
shft: WORD;
final: WORD;
value: WORD _ BITXOR[w1, w2];
value _ BITXOR[value, BITSHIFT[value, -8]];		-- rshift
value _ BITXOR[value, BITSHIFT[value, -4]];		-- rshift
shft _ BITAND[value, 17B];
final _ BITNOT[BITSHIFT[113151B, -shft]];
RETURN[LOOPHOLE[final, ParityWord].parity];
};

AppendEndItem: PROC[
	nextItemAddr: LONG POINTER TO WORD, startAddr: CARDINAL] = TRUSTED {
endItemAddr: LONG POINTER TO end CSItem = LOOPHOLE[nextItemAddr];
checksum: INTEGER _ 0;
addr: LONG POINTER TO INTEGER _ LOOPHOLE[itemArray];
wordsUsed: LONG CARDINAL =
LOOPHOLE[nextItemAddr-itemArray+SIZE[CSItem], LONG CARDINAL];

endItemAddr.type _ itemEnd;
endItemAddr.startAddr _ startAddr;
FOR i: LONG CARDINAL IN [0..wordsUsed) DO
checksum _ checksum + (addr+i)^;
ENDLOOP;
endItemAddr.checksum _ - checksum;
};

WriteEBHeader: PROC[outFile: OutFile] = TRUSTED {
of: FS.OpenFile = FS.OpenFileFromStream[outFile.stream];
ebHeader: LONG POINTER TO EBHeader = LOOPHOLE[scratch];
len: INTEGER = outFile.shortName.Length[];
cdl: Basics.LongNumber = LOOPHOLE[BasicTime.ToPupTime[FS.GetInfo[of].created]];
cdl2: Basics.LongNumber;
cdl2.hi _ cdl.lo;
cdl2.lo _ cdl.hi;		-- swap halves of date

PrincOpsUtils.LongZero[scratch, ebHeaderLength];
ebHeader.etherVersionNumber _ etherVersionNumber;
ebHeader.creationDate _ LOOPHOLE[cdl2];
ebHeader.nameLen _ len;
ebHeader.maxNameLen _ Basics.BITAND[LOOPHOLE[len+1, WORD], 177776B];		-- ugh
FOR i: INTEGER IN [0..len) DO
ebHeader.nameChars[i] _ outFile.shortName.Fetch[i];
ENDLOOP;
outFile.stream.UnsafePutBlock[
[base: LOOPHOLE[scratch], startIndex: 0, count: 2*ebHeaderLength]];
};

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
ReadName: PROC[in: STREAM, buffer: REF TEXT] = {
i: INTEGER _ 0;
DO
char: CHAR _ in.GetChar[];
IF char = '\000 THEN {
IF in.GetIndex[] MOD 2 = 1 THEN [] _ in.GetChar[];	-- stream is word (16-bit) oriented
EXIT;
};
buffer[i] _ char;
i _ i + 1;
ENDLOOP;
buffer.length _ i;
};

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
ShortName: PROC[fullName: ROPE] RETURNS[ROPE] = {
cp: FS.ComponentPositions;
fsName: ROPE;
[fsName, cp, ] _ FS.ExpandName[fullName];
RETURN[fsName.Substr[cp.base.start, cp.base.length+cp.ext.length+1]];	-- +1 for .
};

OutFileNamesFromSrcFile: PROC[outFile: OutFile, srcName, ext: ROPE] = {
cp: FS.ComponentPositions;
fsName: ROPE;
baseName: ROPE;
[fsName, cp, ] _ FS.ExpandName[srcName];
IF cp.ext.length # 0 THEN baseName _ Rope.Substr[fsName, 0, cp.ext.start-1]
ELSE baseName _ Rope.Substr[fsName, 0, cp.ver.start-1];
outFile.fullName _ baseName.Cat[".", ext];
outFile.shortName _ ShortName[outFile.fullName];
};

GetWord: PROC[in: STREAM] RETURNS[WORD] = {
num: Basics.ShortNumber;
num.hi _ LOOPHOLE[in.GetChar[]];
num.lo _ LOOPHOLE[in.GetChar[]];
RETURN[LOOPHOLE[num, WORD]];
};

GetInteger: PROC[in: STREAM] RETURNS[INTEGER] = {
num: Basics.ShortNumber;
num.hi _ LOOPHOLE[in.GetChar[]];
num.lo _ LOOPHOLE[in.GetChar[]];
RETURN[LOOPHOLE[num, INTEGER]];
};

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
TSStream: PROC[name: ROPE] RETURNS [IO.STREAM] = {
v: ViewerClasses.Viewer _ ViewerOps.FindViewer[name];
out: IO.STREAM _ ViewerIO.CreateViewerStreams[name, v].out;
IF v#NIL THEN IF v.iconic THEN ViewerOps.OpenIcon[v];
RETURN[out];
};

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
GetIndex: PROC[strm: STREAM] RETURNS[INT] = { RETURN[strm.GetIndex[]] };

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Commander.Register["LoadMB", Main, "Reads and Loads a MicroBinary file"];

END.

LoadMB.mesa:   Read Dorado MB file
Copyright c 1985 by Xerox Corporation.  All rights reserved.
taken from LoadMB.bcpl
Willie-Sue, April 21, 1988 1:23:20 pm PDT
block types
name starts here - memory name
name starts here - memory name
name starts here - address symbol name
name starts here - external symbol name
Defining an IMWord in the MB-file
IFUMWord0: TYPE = MACHINE DEPENDENT RECORD[		-- IFUM word, in MB file
blank (0: 0..4): 0,
pa (0: 5..5): OneBit,
ifad (0: 6..15): [0..1777B],		-- no need for internal stucture of this field
];
Despite what the manual says, the hardware really wants to see even parity - hence the "not" in the following statements
IF (flag MOD 2)=1 THEN {jump to the start address in the new Ram image}
Note: software must pass (pointer to first item)-1; must skip over it!!!
Converts from the MB name format to a normal ref text.
strips the leading directory stuff from name
Κ%˜šΟnœ™"Icodešœ
Οm
œ1™<Jš
œ™K™)—šœ
Οk	˜
Jš
œ˜Jšœ
Ÿœ
˜J˜
J˜JšœŸœ˜$JšŸœ
˜JšŸœ
˜JšœŸœ˜JšœŸœ˜-Jš
œ"˜"JšœŸœ˜J˜J˜JšœŸœ
˜Jšœ	Ÿœ˜%Jšœ
ŸœB˜QJšŸœ
Ÿœ7˜?—J˜šœŸœ
Ÿ˜š
Ÿ˜Jšœ4ŸœŸœLŸ˜ˆ
—J˜JšœŸ˜J˜JšŸœŸœŸœ
˜JšŸœŸœŸœ
Ÿœ
˜JšœŸœ˜$Jšœ
Ÿœ
˜J˜JšœŸœ
˜J˜š	œŸœŸœ
Ÿ	œ
Ÿœ
˜(J˜J˜J˜J˜J˜Jšœ!Οc˜>Jš
œ˜šœŸœ
ŸœŸ˜%˜	Jšœ
Ÿœ 
˜JšœŸœ ,˜>JšœŸœ ˜)J˜—˜JšœŸœ
˜JšœŸœ "˜:JšœŸœ ˜,J˜—Jš
Ÿ˜—J˜—J˜JšœŸœŸœ
Ÿ	œ1˜UJ˜š
œ™šœŸœŸœ
Ÿ	œ˜%Jšœ ˜Jšœ +˜7Jšœ
 !˜.Jšœ
 ˜'Jšœ #˜4Jšœ ˜'Jšœ ˜%J˜——J˜Jšœ
Ÿœ 
˜*J˜š	œŸœŸœ
Ÿ	œ
Ÿœ
˜(JšœŸœ ˜,JšœŸœ !˜3Jš
œ˜—J˜š	œ
ŸœŸœ
Ÿ	œ
Ÿœ
˜*JšœŸœ ˜#Jšœ
Ÿœ ˜0Jš
œ™Jš
œ˜—J˜š	œ	ŸœŸœ
Ÿ	œ
Ÿœ
˜)JšœŸœ ˜#Jšœ
Ÿœ ˜+Jšœ
Ÿœ ˜-Jšœ	Ÿœ
˜JšœŸœ ˜'J˜—J˜š	œŸœŸœ
Ÿ	œ
Ÿœ
˜.JšœŸœ ˜&JšœŸœ ˜"Jš
œ™J˜—J˜š	œŸœŸœ
Ÿ	œ
Ÿœ
˜+JšœŸœ ˜#JšœŸœ ˜"Jš
œ&™&J˜—J˜š	œ
ŸœŸœ
Ÿ	œ
Ÿœ
˜-JšœŸœ ˜"Jšœ
Ÿœ ˜*Jšœ
Ÿœ ˜,Jšœ	Ÿ˜
Jš
œ'™'J˜—J˜JšœŸœ˜JšœŸœ '˜F—
head™!š
œ
ŸœŸœ
Ÿ	œ
Ÿœ ˜CšŸœ
ŸœŸ˜Jš
œT˜TJš
œ+˜+Jš
Ÿ˜—J˜—J˜š
œ
ŸœŸœ
Ÿ	œ
Ÿœ ˜DšŸœ
ŸœŸ˜Jš
œD˜DJš
œ.˜.Jš
Ÿ˜—J˜—J˜š
œŸœŸœ
Ÿ	œ
Ÿœ ˜EJš
œ˜Jš
œ˜J˜J˜J˜Jš
œ˜Jš
œ˜Jš
œ#˜#Jš
œ˜——J˜
š
œŸœŸœ
Ÿ	œ
Ÿœ ™EJ™J™Jšœ .™LJ™—J˜š	œŸœŸœ
Ÿ	œ
Ÿœ
˜+J˜Jšœ ˜3Jšœ ˜3Jšœ ˜3J˜J˜J˜J˜J˜J˜—J˜š	œ
ŸœŸœ
Ÿ	œ
Ÿœ
˜*JšœŸœ ˜-Jš
œ˜J˜—J˜š
 K˜KJšœ
Ÿœ	˜Jšœ
Ÿœ˜Jšœ
Ÿœ	˜Jšœ
Ÿœ˜Jšœ
Ÿœ˜Jšœ
Ÿœ˜—J˜JšœŸœŸœ "˜8J˜J˜=J˜J˜Jšœ	ŸœŸœ˜J˜šœŸœŸœ ˜4Jš
œ˜JšœŸœ ˜,JšœŸœ
˜JšœŸœ .˜MJš
œ˜—J˜Jšœ	ŸœŸœ˜šœŸœŸœ˜Jšœ
Ÿœ
˜JšœŸœ
˜JšœŸ˜J˜—J˜JšœŸœ(˜:J˜š	œ
ŸœŸœ
Ÿ	œ
Ÿœ
˜*JšœŸœ
˜JšœŸœ˜JšœŸœ
Ÿœ
˜JšœŸœ
˜JšœŸœ
˜JšœŸœ
ŸœŸœ
Ÿ˜(J˜—J˜š	œŸœŸœ
Ÿ	œ
Ÿœ
˜,J˜J˜J˜—J˜Jšœ
Ÿœ ,˜NJšœŸœ
Ÿœ
Ÿœ
ŸœŸœ
˜&JšœŸœŸœ	˜$JšœŸœ˜0Jš	œŸœ
Ÿœ
Ÿœ
Ÿœ
˜#Jšœ	Ÿœ
Ÿœ 4˜LJšœŸœ˜J˜JšœŸœ(˜4Jš	œ
Ÿœ
ŸœŸœ
Ÿœ˜-JšœŸœŸœ
˜!J˜J˜:J˜š
œ˜Jš
œ:˜:JšœŸœ)˜3Jš
œ'˜'Jš
œ˜JšœŸœ
˜JšœŸœ
˜JšœŸœ˜(JšœŸœŸœ
˜JšœŸœ
˜šœŸœŸœ˜$JšœŸœ
˜š
œ	˜	Jšœ:Ÿœ˜A—šŸœŸœ
Ÿœ ˜:šŸœ˜Jš
œ˜Jš
œ˜J˜——Jš
œ˜—J˜Jš
œ(˜(JšœŸœ)˜AšŸœ
Ÿœ
Ÿœ˜JšœŸœ
ŸœŸœŸœŸœ'˜nJšœŸœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ˜7J˜—JšŸœ8˜?šŸœŸœ
Ÿ˜Jšœ
ŸœŸœ˜=—J˜šŸœŸœ
ŸœŸ˜JšœŸœ˜šŸœŸ˜šŸœ˜JšœŸœŸœ
˜šŸœŸœ
Ÿœ˜š
œ˜Jšœ8Ÿœ
˜G—JšŸœ
˜J˜
šŸœ˜Jš
œ˜JšœŸœ
˜J˜——šŸœŸœ
Ÿœ˜š
œ˜Jšœ=Ÿœ
˜L—JšŸœ
˜J˜—J˜š
œI˜IJš
œI˜IJšœŸœ
˜JšŸœ˜—JšŸœŸœ
Ÿœ
˜JšœŸœ
˜J˜—šœ	 ˜JšŸœŸœ
ŸœŸ˜#šŸœŸ˜š
œ˜Jš
œ˜JšœŸœ
˜J˜—š
œ˜Jš
œ˜JšœŸœ
˜J˜—š
œ˜Jš	œŸœŸœŸœŸœ˜BJšœ
Ÿœ
˜JšœŸœ*˜?Jš
œ0˜0JšœŸœ
˜J˜—JšœŸœ
˜šŸœ˜
Jšœ+Ÿœ˜D—JšŸœ
˜—J˜
—šŸœ ˜JšŸœŸœ
Ÿœ˜8Jš
œ˜J˜——JšŸœ
˜—J˜JšŸœŸœ
Ÿœ˜8—˜šŸœŸœ
Ÿœ˜Jš
œ?˜?Jš
Ÿ˜J˜—J˜šŸœŸœ˜!J˜9JšŸœ
˜J˜—šŸœŸœ
ŸœŸ˜6Jšœ"Ÿœ&˜K—J˜Jš
œ˜Jš
œK˜KJ˜J˜—šœŸœ)˜7JšœŸœ&Ÿœ˜QJšœŸœ˜JšœŸœ
˜JšœŸœ
˜	J˜šŸœŸœ
Ÿœ˜&JšŸœI˜K—J˜šŸœŸœ˜<J˜—šŸœ)ŸœŸœ
Ÿ˜?š
Ÿ˜šœŸœŸœ	˜3Jšœ&Ÿœ	˜4—J˜Jšœ'Ÿœ˜<Jš
œ1˜1šŸœŸœ˜
J˜;Jš
œ˜Jš
ŸœŸœ
ŸœŸœ
Ÿœ˜FJšŸœ
˜J˜—JšŸœŸœ&˜FJš
œ˜Jš
œ,˜,Jšœ. ˜@˜DJšŸœŸœŸœ˜@—J˜šŸœŸœ
Ÿœ #˜N˜JšœŸœ>˜M—Jš
œ9˜9J˜—š
Ÿ˜JšœŸœ
˜
—JšŸœ
˜—JšŸœ
˜—š
ŸœŸœ
ŸœŸœ
Ÿœ˜0˜,JšŸœ"Ÿœ˜?—Jš
œ˜J˜—J˜4šŸœŸœŸœ˜,JšŸœŸœ
Ÿœ
˜&J˜šŸœ@Ÿœ˜HK˜&Kš
Ÿ˜K˜—KšœŸœ˜)K˜—J˜—J˜šœŸœ
ŸœŸœ˜-KšœŸœŸœ
˜š
œ"˜"KšŸœŸœŸœ	Ÿœ
Ÿœ
Ÿœ
˜;KšŸœŸœ!˜5Kš
œ˜—K˜'šŸœŸœ˜K˜šŸœ;Ÿœ˜CK˜&KšŸœ
Ÿœ
˜Kš
œ˜—Kš
œ˜—KšŸœ
Ÿœ
˜
Kš
œ˜K˜—Jš
 :˜:š
œŸœŸœ˜5Jš	œ
ŸœŸœŸœŸœ˜2JšœŸœ˜JšœŸœ˜Jš
œ˜Jš	œŸœŸœ
ŸœŸœ˜>JšœŸœ˜$Jšœ)Ÿœ˜6JšœŸœ˜Jš	œŸœ
ŸœŸœŸœ˜IJšœŸœ
Ÿœ
Ÿœ
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ˜CJ˜š
œŸœŸœŸœŸœ˜GJšœŸœ˜JšŸœ
Ÿœ˜!J˜—J˜Jš
œ˜JšœŸœ
˜
Jš
œ˜š
Ÿ˜JšœŸœ˜!JšœŸœ
Ÿœ
Ÿœ˜Jš
œ-˜-Jšœ	Ÿœ˜ J˜šŸœ
Ÿ˜Jšœ	ŸœŸœ˜%J˜š
œ˜Jšœ ˜0šŸœŸ˜šŸœŸœ
ŸœŸ˜/Jšœ!Ÿœ
˜)——J˜šŸœŸ˜˜Jš	œ
Ÿœ
Ÿœ
Ÿœ
Ÿœ˜5JšœŸœ˜4JšœŸœ˜4JšœŸœ˜4Jš
œ˜Jš
œ'˜'Jš
œ5˜5Jš
œ7˜7Jš
œ!˜!Jš
œ˜Jš
œ#˜#Jš
œ˜Jš
œ"˜"Jš
œ)˜)J˜—˜Jš	œŸœ
Ÿœ
ŸœŸœ˜9Jš
œ˜Jš
œ˜—š
œx™xš
œ˜šœŸœ ˜:JšœŸœ
Ÿœ#˜9——š
œ˜šœŸœ ˜:JšœŸœ
Ÿœ#˜9——š
œ˜šœŸœ ˜:JšœŸœ
Ÿœ#˜9——J˜Jš
œ#˜#JšœŸœ˜-Jš
œ"˜"Jš
œ)˜)J˜J˜—˜Jš	œ
Ÿœ
Ÿœ
Ÿœ
Ÿœ˜5Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ"˜"Jš
œ)˜)Jš
œ˜J˜—˜J˜7—JšŸœŸœ
˜—J˜—J˜š
œ
˜
Jš
œ ˜ šŸœŸœ˜"Jšœ;Ÿœ˜KJšŸœŸœ
˜J˜—Jš
œ˜J˜—J˜š
œ˜Jš
œD˜DJšŸœŸœ
˜J˜—J˜š
œ˜JšœŸœ˜/JšœŸœ˜"JšœŸœ˜JšœŸœ
˜Jš
œ˜šŸœŸœ˜%Jšœ6Ÿœ˜MJšŸœŸœ˜Jš
œ˜—Jšœ$Ÿœ
˜6Jš
œ)˜)šŸœ
Ÿœ
Ÿ˜JšœŸœ ˜6JšœŸœ"˜:JšœŸœ ˜6šŸœ˜
Jšœ-Ÿœ
˜<——J˜—J˜š
œ˜J˜Jš
œ˜Jš
œ$˜$Jš
œ˜—J˜š
œ˜Jš
œB˜BJšŸœŸœ˜J˜—J˜šŸœ˜š
œ3˜3JšŸœŸœŸœ˜)—JšŸœŸœ˜J˜—JšŸœ
˜—J˜——J˜š
œŸœŸœ
ŸœŸœ˜?Jš
œG™GJš
œH™HJšœ
Ÿœ
Ÿœ
Ÿœ&˜;J˜—šœŸœ	ŸœŸœ˜?JšŸœ˜JšœŸœ
˜JšœŸœ
˜JšœŸœŸœ	˜JšœŸœŸœ 	˜6JšœŸœŸœ 	˜6JšœŸœ
˜JšœŸœ
Ÿœ˜)JšŸœ
Ÿœ˜+J˜—J˜š
œŸœ
˜Jš
œŸœ
Ÿœ
Ÿœ
Ÿœ
ŸœŸœ˜EJš	œ
Ÿœ
Ÿœ
ŸœŸœ˜AJšœ
Ÿœ˜JšœŸœ
Ÿœ
Ÿœ
ŸœŸœ˜4šœŸœ
Ÿœ˜JšŸœŸœ
Ÿœ
Ÿœ˜=—J˜Jš
œ˜Jš
œ"˜"š	ŸœŸœ
Ÿœ
ŸœŸ˜)Jš
œ ˜ JšŸœ
˜—Jš
œ"˜"J˜—J˜š
œŸœŸœ˜1JšœŸœŸœ$˜8Jš	œ
Ÿœ
Ÿœ
ŸœŸœ
˜7JšœŸœ˜*JšœŸœŸœ˜OJš
œ˜J˜Jšœ ˜)J˜Jš
œ0˜0Jš
œ1˜1JšœŸœ˜'Jš
œ˜JšœŸœ
ŸœŸœ ˜LšŸœŸœ
Ÿœ
Ÿ˜Jš
œ3˜3JšŸœ
˜—š
œ˜JšœŸœ4˜C—J˜—J˜J˜:š
œŸœŸœ
Ÿœ
Ÿœ˜0Jš
œ6™6JšœŸœ˜š
Ÿ˜JšœŸœ˜šŸœŸœ˜JšŸœŸœŸœ #˜VJšŸœ
˜J˜—J˜J˜
JšŸœ
˜—Jš
œ˜Jš
œ˜—J˜J˜:š
	œŸœŸœŸœ
Ÿœ˜1Jš
œ,™,J˜JšœŸœ
˜
JšœŸœ˜)JšŸœ@ ˜QJ˜—J˜šœŸœ!Ÿœ˜GJ˜JšœŸœ
˜
Jšœ
Ÿœ
˜JšœŸœ˜(šœŸœ2˜KJšŸœ3˜7—Jš
œ*˜*Jš
œ0˜0J˜—J˜š
œŸœŸœŸœ
Ÿœ˜+Jš
œ˜Jšœ	Ÿœ˜ Jšœ	Ÿœ˜ JšŸœ
ŸœŸœ˜Jš
œ˜—J˜š

œŸœŸœŸœ
Ÿœ˜1Jš
œ˜Jšœ	Ÿœ˜ Jšœ	Ÿœ˜ JšŸœ
ŸœŸœ˜Jš
œ˜—J˜J˜:šœŸœŸœŸœŸœ
Ÿœ˜2Jš
œ5˜5JšœŸœ
Ÿœ,˜;Jš
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ˜5JšŸœ˜Jš
œ˜—J˜J˜:JšœŸœŸœŸœ
ŸœŸœ˜HJ˜J˜:˜Jš
œI˜I—J˜JšŸœ
˜J˜—…—J$fΩ