DIRECTORY
Ascii USING [SP],
BcdDefs USING [Base, CTIndex, CTNull, FPIndex, GFTIndex, MTIndex, NTIndex, SPIndex],
BcdOps USING [
BcdBase, CTHandle, FPHandle, MTHandle, NameString, NTHandle, ProcessConfigs, ProcessFramePacks, ProcessModules, ProcessNames, ProcessSpaces, SPHandle],
LongString USING [EqualSubStrings, SubStringDescriptor],
MB USING [Abort, BHandle, BIndex, Handle],
MBTTY USING [Handle, PutCR, PutChar, PutString],
MBVM USING [CopyRead],
PrincOps USING [GlobalFrame, GlobalFrameHandle];

MBUtilities: PROGRAM
IMPORTS BcdOps, MB, MBTTY, MBVM, String: LongString
EXPORTS MB =

BEGIN

SubStringDescriptor: TYPE = String.SubStringDescriptor;

data: MB.Handle _ NIL;
mainBcd: MB.BHandle _ NIL;

currentBH: MB.BHandle;
currentCti: BcdDefs.CTIndex;
currentConfig: LONG STRING;


InitUtilities: PUBLIC PROC [h: MB.Handle] = {
data _ h;
ResetConfig[];
currentFrame _ NIL;
};

FinishUtilities: PUBLIC PROC = {data _ NIL};


NameToG: PUBLIC PROC [name: LONG STRING] RETURNS [PrincOps.GlobalFrameHandle] = {
bh: MB.BHandle;
mth: BcdOps.MTHandle;
[bh, mth] _ NameToMTHandle[name];
RETURN[IF mth ~= NIL THEN bh.mt[mth.gfi].frame ELSE NIL]
};

NameToMTHandle: PUBLIC PROC [name: LONG STRING]
RETURNS [bh: MB.BHandle, mth: BcdOps.MTHandle] = {
ss: SubStringDescriptor _ [base: name, offset: 0, length: name.length];
nmth: BcdOps.MTHandle _ NIL;
DoOneBCD: PROC [thisBH: MB.BHandle] RETURNS [BOOL] = {
bcd: BcdOps.BcdBase = thisBH.bcd;
ssb: BcdOps.NameString = LOOPHOLE[bcd + bcd.ssOffset];
bname: SubStringDescriptor;
CheckModule: PROC [mth: BcdOps.MTHandle, mti: BcdDefs.MTIndex]
RETURNS [BOOL] = {
IF currentCti ~= BcdDefs.CTNull AND
(currentBH ~= thisBH OR mth.config ~= currentCti) THEN RETURN[FALSE];
IF mth.namedInstance THEN RETURN[FALSE];
bname.offset _ mth.name;
bname.length _ ssb.size[mth.name];
IF String.EqualSubStrings[@ss, @bname] THEN
IF nmth = NIL THEN {bh _ thisBH; nmth _ mth}
ELSE AmbiguousName[name: name];
RETURN[FALSE]
};
bname.base _ @ssb.string;
[] _ BcdOps.ProcessModules[bcd, CheckModule];
RETURN[FALSE]
};
[] _ DoAllBCDs[DoOneBCD];
IF (mth _ nmth) ~= NIL THEN RETURN;
SearchError[thing: "module"L, s1: name];
RETURN[NIL, NIL]
};

AmbiguousName: PROC [name: LONG STRING] = {
OPEN MBTTY;
tty: MBTTY.Handle = data.ttyHandle;
PutCR[tty];
PutString[tty, "!Ambiguous name "L];
IF currentConfig ~= NIL THEN {PutString[tty, currentConfig];  PutChar[tty, '[]};
PutString[tty, name];
IF currentConfig ~= NIL THEN PutChar[tty, ']];
PutCR[tty];
SIGNAL MB.Abort;
};

SearchError: PROC [thing: LONG STRING, s1: LONG STRING, s2: LONG STRING _ NIL] = {
OPEN MBTTY;
tty: MBTTY.Handle = data.ttyHandle;
IF data.inputBCDs.bcds[data.inputBCDs.nBcds-1].bcd = NIL THEN RETURN;
PutCR[tty];
PutString[tty, "!Can't find "L];
PutString[tty, thing]; PutChar[tty, Ascii.SP];
IF currentConfig ~= NIL THEN {PutString[tty, currentConfig];  PutChar[tty, '[]};
PutString[tty, s1];
IF s2 ~= NIL THEN {PutChar[tty, '.];  PutString[tty, s2]};
IF currentConfig ~= NIL THEN PutChar[tty, ']];
PutCR[tty];
SIGNAL MB.Abort;
};

NameToFPHandle: PUBLIC PROC [name: LONG STRING]
RETURNS [bh: MB.BHandle, fph: BcdOps.FPHandle] = {
ss: SubStringDescriptor _ [base: name, offset: 0, length: name.length];
DoOneBCD: PROC [thisBH: MB.BHandle] RETURNS [BOOL] = {
bcd: BcdOps.BcdBase = (bh _ thisBH).bcd;
ssb: BcdOps.NameString = LOOPHOLE[bcd + bcd.ssOffset];
bname: SubStringDescriptor;
CheckFramePack: PROC [fph: BcdOps.FPHandle, fpi: BcdDefs.FPIndex] RETURNS [BOOL] = {
bname.offset _ fph.name;
bname.length _ ssb.size[fph.name];
RETURN[String.EqualSubStrings[@ss, @bname]]
};
bname.base _ @ssb.string;
RETURN[(fph _ BcdOps.ProcessFramePacks[bcd, CheckFramePack].fph) ~= NIL]
};
IF DoAllBCDs[DoOneBCD] THEN RETURN;
SearchError[thing: "frame pack"L, s1: name];
RETURN[NIL, NIL]
};

NameToSPHandle: PUBLIC PROC [name: LONG STRING]
RETURNS [bh: MB.BHandle, sph: BcdOps.SPHandle, index: CARDINAL] = {
ss: SubStringDescriptor _ [base: name, offset: 0, length: name.length];
DoOneBCD: PROC [thisBH: MB.BHandle] RETURNS [BOOL] = {
bcd: BcdOps.BcdBase = (bh _ thisBH).bcd;
ssb: BcdOps.NameString = LOOPHOLE[bcd + bcd.ssOffset];
bname: SubStringDescriptor;
CheckSpace: PROC [sph: BcdOps.SPHandle, spi: BcdDefs.SPIndex]
RETURNS [BOOL] = {
FOR i: CARDINAL IN [0..sph.length) DO
bname.offset _ sph.spaces[i].name;
bname.length _ ssb.size[sph.spaces[i].name];
IF String.EqualSubStrings[@ss, @bname] THEN {index _ i; RETURN[TRUE]};
ENDLOOP;
RETURN[FALSE]
};
bname.base _ @ssb.string;
RETURN[(sph _ BcdOps.ProcessSpaces[bcd, CheckSpace].sph) ~= NIL]
};
IF DoAllBCDs[DoOneBCD] THEN RETURN;
SearchError[thing: "code pack"L, s1: name];
RETURN[NIL, NIL, 0]
};

NameToCTHandle: PUBLIC PROC [name: LONG STRING]
RETURNS [bh: MB.BHandle, cth: BcdOps.CTHandle] = {
ss: SubStringDescriptor _ [base: name, offset: 0, length: name.length];
DoOneBCD: PROC [thisBH: MB.BHandle] RETURNS [BOOL] = {
bcd: BcdOps.BcdBase = (bh _ thisBH).bcd;
ssb: BcdOps.NameString = LOOPHOLE[bcd + bcd.ssOffset];
cname: SubStringDescriptor;
CheckConfig: PROC [cth: BcdOps.CTHandle, cti: BcdDefs.CTIndex]
RETURNS [BOOL] = {
cname.offset _ cth.name;
cname.length _ ssb.size[cth.name];
RETURN[String.EqualSubStrings[@ss, @cname]]
};
cname.base _ @ssb.string;
IF bcd.nConfigs = 0 THEN {
mth: BcdOps.MTHandle _ LOOPHOLE[bcd + bcd.mtOffset];
cname.offset _ mth.name;
cname.length _ ssb.size[mth.name];
RETURN[String.EqualSubStrings[@ss, @cname]]
}
ELSE RETURN[(cth _ BcdOps.ProcessConfigs[bcd, CheckConfig].cth) ~= NIL]
};
cth _ NIL;
IF DoAllBCDs[DoOneBCD] THEN RETURN;
SearchError[thing: "configuration"L, s1: name];
RETURN[NIL, NIL]
};

InstanceToMTHandle: PUBLIC PROC [module, instance: LONG STRING]
RETURNS [bh: MB.BHandle, mth: BcdOps.MTHandle] = {
mss: SubStringDescriptor _ [base: module, offset: 0, length: module.length];
iss: SubStringDescriptor _ [base: instance, offset: 0, length: instance.length];
DoOneBCD: PROC [thisBH: MB.BHandle] RETURNS [BOOL] = {
bcd: BcdOps.BcdBase = (bh _ thisBH).bcd;
mtb: BcdDefs.Base = LOOPHOLE[bcd + bcd.mtOffset];
ssb: BcdOps.NameString = LOOPHOLE[bcd + bcd.ssOffset];
bname: SubStringDescriptor;
CheckName: PROC [nth: BcdOps.NTHandle, nti: BcdDefs.NTIndex] RETURNS [BOOL] = {
WITH nth.item SELECT FROM
module => {
bname.offset _ nth.name;
bname.length _ ssb.size[nth.name];
IF String.EqualSubStrings[@iss, @bname] THEN {
IF currentCti ~= BcdDefs.CTNull AND
(currentBH ~= bh OR mtb[mti].config ~= currentCti) THEN RETURN[FALSE];
bname.offset _ mtb[mti].name;
bname.length _ ssb.size[mtb[mti].name];
IF String.EqualSubStrings[@mss, @bname] THEN {
mth _ @mtb[mti];
RETURN[TRUE]
};
};
};
ENDCASE => RETURN[FALSE];
RETURN[FALSE]};
bname.base _ @ssb.string;
RETURN[BcdOps.ProcessNames[bcd, CheckName].nth ~= NIL]
};
mth _ NIL;
IF DoAllBCDs[DoOneBCD] THEN RETURN;
SearchError[thing: "module instance"L, s1: instance, s2: module];
RETURN[NIL, NIL]
};

DoAllModules: PUBLIC PROC [proc: PROC [MB.BHandle, BcdOps.MTHandle] RETURNS [BOOL]]
RETURNS [BOOL] = {
IF currentCti = BcdDefs.CTNull THEN {
DoOneBCD: PROC [bh: MB.BHandle] RETURNS [BOOL] = {
PassItOn: PROC [mth: BcdOps.MTHandle, mti: BcdDefs.MTIndex] RETURNS [BOOL] = {
RETURN[proc[bh, mth]]};
RETURN[BcdOps.ProcessModules[bh.bcd, PassItOn].mth ~= NIL]
};
RETURN[DoAllBCDs[DoOneBCD]]
}
ELSE {
bcd: BcdOps.BcdBase = currentBH.bcd;
ctb: BcdDefs.Base = LOOPHOLE[bcd + bcd.ctOffset];
DoOneModule: PROC [mth: BcdOps.MTHandle, mti: BcdDefs.MTIndex] RETURNS [BOOL] = {
FOR cti: BcdDefs.CTIndex _ mth.config, ctb[cti].config UNTIL cti = BcdDefs.CTNull DO
IF cti = currentCti AND proc[currentBH, mth] THEN RETURN[TRUE];
ENDLOOP;
RETURN[FALSE]
};
RETURN[BcdOps.ProcessModules[bcd, DoOneModule].mth ~= NIL]
};
};

DoAllBCDs: PUBLIC PROC [proc: PROC [MB.BHandle] RETURNS [BOOL]] RETURNS [BOOL] = {
FOR i: MB.BIndex IN [0..data.inputBCDs.nBcds) DO
bh: MB.BHandle = data.inputBCDs.bcds[i];
IF bh.bcd ~= NIL AND proc[bh] THEN RETURN[TRUE];
ENDLOOP;
RETURN[FALSE]
};

DoAllSpaces: PUBLIC PROC [
proc: PROC [MB.BHandle, BcdOps.SPHandle, CARDINAL] RETURNS [BOOL]]
RETURNS [BOOL] = {
DoOneBCD: PROC [bh: MB.BHandle] RETURNS [BOOL] = {
PassItOn: PROC [sph: BcdOps.SPHandle, spi: BcdDefs.SPIndex]
RETURNS [BOOL] = {
FOR i: CARDINAL IN [0..sph.length) DO
IF proc[bh, sph, i] THEN RETURN[TRUE];
ENDLOOP;
RETURN[FALSE]
};
RETURN[BcdOps.ProcessSpaces[bh.bcd, PassItOn].sph ~= NIL]
};
RETURN[DoAllBCDs[DoOneBCD]]
};

DoAllFramePacks: PUBLIC PROC [
proc: PROC [MB.BHandle, BcdOps.FPHandle] RETURNS [BOOL]]
RETURNS [BOOL] = {
DoOneBCD: PROC [bh: MB.BHandle] RETURNS [BOOL] = {
PassItOn: PROC [fph: BcdOps.FPHandle, fpi: BcdDefs.FPIndex] RETURNS [BOOL] = {
RETURN[proc[bh, fph]]
};
RETURN[BcdOps.ProcessFramePacks[bh.bcd, PassItOn].fph ~= NIL]
};
RETURN[DoAllBCDs[DoOneBCD]]
};

SetConfig: PUBLIC PROC [name: LONG STRING] = {
ss: SubStringDescriptor _ [base: name, offset: 0, length: name.length];
DoOneBCD: PROC [bh: MB.BHandle] RETURNS [BOOL] = {
bcd: BcdOps.BcdBase = bh.bcd;
ssb: BcdOps.NameString;
cti: BcdDefs.CTIndex;
bname: SubStringDescriptor;
CheckConfig: PROC [cth: BcdOps.CTHandle, cti: BcdDefs.CTIndex] RETURNS [BOOL] = {
bname.offset _ cth.name;
bname.length _ ssb.size[cth.name];
RETURN[String.EqualSubStrings[@ss, @bname]]
};
ssb _ LOOPHOLE[bcd + bcd.ssOffset];
bname.base _ @ssb.string;
IF (cti _ BcdOps.ProcessConfigs[bcd, CheckConfig].cti) ~= BcdDefs.CTNull THEN {
currentBH _ bh;
currentCti _ cti;
currentConfig _ name;
RETURN[TRUE]
};
RETURN[FALSE]
};
[] _ DoAllBCDs[DoOneBCD]
};

ResetConfig: PUBLIC PROC = {
currentBH _ NIL;
currentCti _ BcdDefs.CTNull;
currentConfig _ NIL;
};

globalFrame: PrincOps.GlobalFrame;
currentFrame: PrincOps.GlobalFrameHandle;

VirtualGlobalFrame: PUBLIC PROC [f: PrincOps.GlobalFrameHandle]
RETURNS [PrincOps.GlobalFrameHandle] = {
IF f ~= currentFrame THEN {
MBVM.CopyRead[from: f, to: @globalFrame, nwords: SIZE[PrincOps.GlobalFrame]];
currentFrame _ f;
};
RETURN[@globalFrame]
};

END.




VMBUtilities.mesa  
Edited by Sandman on 6-Aug-81 15:47:39
Edited by Lewis on 17-Sep-81 15:51:36
Edited by Levin on April 5, 1983 3:51 pm
don't give error message if not all BCDs have been loaded.
assert: bcd.nModules = 1
do all modules in all loaded BCDs
do only modules within <currentBH.bcd, currentCti>, including subconfigurations
�Ê
D˜Jš
œ™Jš
œ&™&Jš
œ%™%Jš
œ(™(J˜š
Ïk	˜	Jšœ�œ�œ˜Jšœ�œG˜Tšœ�œ˜J˜—
—Jšœ�œ(˜8Jš�œ
�œ"˜*Jš�œ
�œ%˜0Jš�œ
�œ˜Jšœ	�œ"˜0J˜—šœ
�˜Jš�œ	�œ�œ�œ˜3Jš�œ
�œ˜—J˜Jš
�˜J˜šœ�œ˜7J˜—Jšœ�œ
�œ
˜Jšœ	�œ�œ
˜J˜Jšœ�œ	˜J˜Jšœ�œ
�œ
˜J˜J˜šÏn
œ�œ
�œ�œ˜-J˜	J˜Jšœ�˜Jš
œ˜J˜—Jšžœ�œ
�œ�œ˜,J˜J˜šžœ�œ
�œ�œ
�œ�œ!˜QJšœ�œ	˜J˜J˜!Jš�œ
�œ�œ
�œ�œ
�œ
˜8Jš
œ˜J˜—š
žœ�œ
�œ�œ
�œ
˜/Jš�œ�œ#˜2J˜GJšœ�œ
˜š
žœ�œ
�œ
�œ�œ˜6J˜!Jšœ�œ˜6J˜šžœ�œ-˜>Jš�œ�œ˜š�œ�˜#Jš	œ�œ�œ
�œ
�œ˜E—Jš�œ�œ
�œ
�œ˜(J˜J˜"š�œ%�˜+Jš�œ�œ
�œ˜,Jš�œ˜—Jš�œ
�œ
˜
Jš
œ˜—J˜J˜-Jš�œ
�œ
˜
Jš
œ˜—J˜Jš�œ�œ
�œ
�œ
˜#J˜(Jš�œ
�œ�œ
˜Jš
œ˜J˜—šž
œ�œ�œ
�œ˜+Jš�œ
�œ
˜Jšœ�œ˜#J˜J˜$Jš�œ�œ
�œ4˜PJ˜Jš�œ�œ
�œ˜.J˜Jš�œ
�œ˜Jš
œ˜J˜—šžœ�œ	�œ
�œ�œ
�œ�œ
�œ�œ˜RJš�œ
�œ
˜Jšœ�œ˜#Jš
œ:™:Jš�œ3�œ
�œ
�œ
˜EJ˜J˜ Jšœ*�œ˜.Jš�œ�œ
�œ4˜PJ˜Jš�œ�œ
�œ)˜:Jš�œ�œ
�œ˜.J˜Jš�œ
�œ˜Jš
œ˜J˜—š
žœ�œ
�œ�œ
�œ
˜/Jš�œ�œ#˜2J˜Gš
žœ�œ
�œ
�œ�œ˜6J˜(Jšœ�œ˜6J˜šžœ�œ.�œ�œ˜TJ˜J˜"Jš�œ%˜+Jš
œ˜—J˜Jš�œ>�œ
˜HJš
œ˜—Jš�œ�œ
�œ
˜#J˜,Jš�œ
�œ�œ
˜Jš
œ˜J˜—š
žœ�œ
�œ�œ
�œ
˜/Jš�œ�œ'�œ˜CJ˜Gš
žœ�œ
�œ
�œ�œ˜6J˜(Jšœ�œ˜6J˜šž
œ�œ-˜=Jš�œ�œ˜š�œ�œ
�œ�˜%J˜"J˜,Jš�œ%�œ
�œ
�œ˜FJš�œ
˜—Jš�œ
�œ
˜
Jš
œ˜—J˜Jš�œ6�œ
˜@Jš
œ˜—Jš�œ�œ
�œ
˜#J˜+Jš�œ
�œ�œ˜Jš
œ˜J˜—š
žœ�œ
�œ�œ
�œ
˜/Jš�œ�œ#˜2J˜Gš
žœ�œ
�œ
�œ�œ˜6J˜(Jšœ�œ˜6J˜šžœ�œ-˜>Jš�œ�œ˜J˜J˜"Jš�œ%˜+Jš
œ˜—J˜š�œ�œ˜Jš
œ™Jšœ�œ˜4J˜J˜"Jš�œ%˜+Jš
œ
˜
—Jš�œ
�œ8�œ
˜GJš
œ˜—Jšœ�œ
˜
Jš�œ�œ
�œ
˜#J˜/Jš�œ
�œ�œ
˜Jš
œ˜J˜—š
žœ�œ
�œ�œ
�œ
˜?Jš�œ�œ#˜2J˜LJ˜Pš
žœ�œ
�œ
�œ�œ˜6J˜(Jšœ�œ˜1Jšœ�œ˜6J˜šž	œ�œ.�œ�œ˜Oš�œ
�œ
�˜˜J˜J˜"š�œ&�œ˜.š�œ�˜#Jš	œ�œ �œ
�œ
�œ˜F—J˜J˜'š�œ&�œ˜.Jš
œ˜Jš�œ
�œ
˜Jš
œ˜—Jš
œ˜—Jš
œ˜—Jš�œ�œ
�œ˜—Jš�œ
�œ˜—J˜Jš�œ,�œ
˜6Jš
œ˜—Jšœ�œ
˜
Jš�œ�œ
�œ
˜#J˜AJš�œ
�œ�œ
˜Jš
œ˜J˜—šžœ�œ
�œ�œ�œ�œ�œ˜SJš�œ�œ˜š�œ�œ˜%Jš
œ!™!š
žœ�œ�œ
�œ�œ˜2šžœ�œ.�œ�œ˜NJš�œ˜—Jš�œ0�œ
˜:Jš
œ˜—Jš�œ˜Jš
œ
˜
—š�œ˜Jš
œO™OJ˜$Jšœ�œ˜1šžœ�œ.�œ�œ˜Qš�œ4�œ�˜TJš
�œ�œ�œ
�œ
�œ˜?Jš�œ
˜—Jš�œ
�œ
˜
Jš
œ˜—Jš�œ0�œ
˜:Jš
œ˜—š
œ˜J˜——šž	œ�œ
�œ�œ�œ
�œ�œ�œ�œ˜Rš�œ�œ�œ�˜0Jšœ�œ"˜(Jš�œ�œ
�œ
�œ
�œ
�œ˜0Jš�œ
˜—Jš�œ
�œ
˜
Jš
œ˜J˜—šžœ�œ
�œ˜Jšœ�œ�œ�œ�œ�œ˜BJš�œ�œ˜š
žœ�œ�œ
�œ�œ˜2šžœ�œ-˜;Jš�œ�œ˜š�œ�œ
�œ�˜%Jš�œ�œ
�œ
�œ˜&Jš�œ
˜—Jš�œ
�œ
˜
Jš
œ˜—Jš�œ/�œ
˜9Jš
œ˜—Jš�œ˜Jš
œ˜J˜—šžœ�œ
�œ˜Jš	œ�œ�œ�œ�œ˜8Jš�œ�œ˜š
žœ�œ�œ
�œ�œ˜2šžœ�œ.�œ�œ˜NJš�œ˜Jš
œ˜—Jš�œ3�œ
˜=Jš
œ˜—Jš�œ˜Jš
œ˜J˜—š
ž	œ�œ
�œ�œ
�œ˜.J˜Gš
žœ�œ�œ
�œ�œ˜2J˜J˜J˜J˜šžœ�œ.�œ�œ˜QJ˜J˜"Jš�œ%˜+Jš
œ˜—Jšœ�œ˜#J˜š�œG�œ˜OJš
œ˜Jš
œ˜Jš
œ˜Jš�œ
�œ
˜Jš
œ˜—Jš�œ
�œ
˜
Jš
œ˜—J˜J˜J˜—šžœ�œ
�œ˜Jšœ�œ
˜J˜Jšœ�˜Jš
œ˜J˜—J˜"J˜)J˜šžœ�œ
�œ ˜?Jš�œ!˜(š�œ�œ˜Jš�œ-�œ˜MJ˜J˜—Jš�œ˜Jš
œ˜J˜—Jš�œ
˜˜J˜J˜——…—&f5