DIRECTORY
Ascii USING [BS, ControlA, ControlQ, ControlW, ControlX, CR, DEL, Digit, Letter, Lower, SP, Upper],
BasicTime USING [Now, ToNSTime],
Booting USING [Switches],
Convert USING [RopeFromInt],
DefaultRemoteNames USING [DefaultNames, Get],
Disk USING [Channel, DriveAttributes, NextChannel, PageCount, PageNumber],
File USING [Error, FindVolumeFromName, GetVolumeName, NextVolume, RC, SystemVolume, Volume, VolumeFile, VolumeID],
FileExtra USING [ReserveNoPages, ReservePages],
FormatDisk USING [altoRegionJargon, altoRegionsBottomUp, altoRegionsMax, altoRegionsSize, altoRegionsStart, hardUCodeSize, hardUCodeStart, Start],
FS USING [Error, FileInfo, StreamOpen],
FSPseudoServers USING [GetPseudoServers, PseudoServerList],
FSPseudoServersExtra USING [InsertPseudoServer, Lookup, PseudoServerFromRope, RopeFromPseudoServer],
GermSwap USING [Switch],
IagoOps USING [CommandInfo, CommandList, VolumeID],
IO USING [Close, EndOfStream, EraseChar, GetChar, GetLineRope, GetTokenRope, IDProc, PutChar, PutF, PutFR, PutRope, STREAM],
PhysicalVolume USING [NextPhysical, Physical, PhysicalInfo, PhysicalRC],
ProcessorFace USING [processorID],
Rope USING [Cat, Compare, Concat, Equal, Fetch, Find, FromChar, Length, ROPE, Replace, Run, SkipTo, Substr],
SystemVersion USING [machineType];

IagoOpsImpl: CEDAR PROGRAM
IMPORTS Ascii, BasicTime, Convert, DefaultRemoteNames, Disk, File, FileExtra, FormatDisk, FS, FSPseudoServers, FSPseudoServersExtra, IO, PhysicalVolume, ProcessorFace, Rope, SystemVersion
EXPORTS File--VolumeID--, IagoOps
= BEGIN

ROPE: TYPE = Rope.ROPE;
STREAM: TYPE = IO.STREAM;



Rubout: PUBLIC ERROR = CODE;

GetID: PUBLIC PROC
[in, out: STREAM, default: ROPE, init: ROPE _ NIL, echo: BOOL _ TRUE]
RETURNS [id: ROPE, c: CHAR] = {
OPEN Ascii;
firstTime: BOOL _ init = NIL;
EraseAll: PROC = {
IF echo THEN
FOR i: INT DECREASING IN [0..id.Length[]) DO out.EraseChar[id.Fetch[i]]; ENDLOOP;
id _ NIL;
};
Done: PROC [c: CHAR] RETURNS [BOOL] = INLINE {
IF firstTime THEN {
SELECT c FROM
ControlA, BS, ControlQ, ControlW, ControlX, CR, SP, DEL => NULL;
ENDCASE => EraseAll[];
firstTime _ FALSE;
};
RETURN [c = SP OR c = CR OR c = '?]
};
id _ Rope.Cat[init, default];
IF echo THEN IO.PutRope[out, default];
c _ IO.GetChar[in];
UNTIL Done[c] DO
SELECT c FROM
DEL => ERROR Rubout;
ControlA, BS => {
len: INT _ id.Length[];
IF len > 0 THEN {
len _ len - 1;
IF echo THEN out.EraseChar[id.Fetch[len]];
id _ id.Substr[len: len];
};
};
ControlW, ControlQ => {
alpha: BOOL _ FALSE;
FOR i: INT DECREASING IN [0..id.Length[]) DO
ch: CHAR = id.Fetch[i];
IF Ascii.Letter[ch] OR Ascii.Digit[ch] THEN alpha _ TRUE
ELSE IF alpha THEN {id _ id.Substr[len: i + 1]; EXIT};
IF echo THEN out.EraseChar[ch];
REPEAT
FINISHED => id _ NIL;
ENDLOOP;
};
ControlX => EraseAll[];
ENDCASE => {id _ id.Cat[Rope.FromChar[c]]; IF echo THEN IO.PutChar[out, c]};
c _ IO.GetChar[in];
ENDLOOP;
};

commandList: IagoOps.CommandList _ NIL;

RegisterCommand: PUBLIC PROC [info: IagoOps.CommandInfo] = {
new: IagoOps.CommandList = LIST[info];
lag: IagoOps.CommandList _ NIL;
FOR each: IagoOps.CommandList _ commandList, each.rest WHILE each # NIL DO
full: ROPE _ each.first.fullName;
SELECT Rope.Compare[info.fullName, full, FALSE] FROM
less => {
new.rest _ each;
EXIT;
};
equal => {
each.first _ info;
RETURN;
};
ENDCASE;
lag _ each;
ENDLOOP;
IF lag = NIL THEN commandList _ new ELSE lag.rest _ new;
};

GetCommandList: PUBLIC PROC RETURNS [IagoOps.CommandList] = {
RETURN [commandList];
};

isDiskReadable: BOOL _ TRUE;
GetCommand: PUBLIC PROC
[in, out: STREAM, diskReadable: BOOL] RETURNS [found: IagoOps.CommandInfo] = {
prompt: ROPE = "\n\n> ";
BoolFalse: TYPE = BOOL _ FALSE;
prefix: ROPE _ NIL;
isDiskReadable_ diskReadable;
IO.PutRope[out, prompt];
DO
end: CHAR;
matches: { none, one, many } _ none;
uniqueLength: INT;
[id: prefix, c: end] _ GetID[in: in, out: out, default: NIL, init: prefix];
uniqueLength _ prefix.Length[];
IF end = '? THEN IO.PutChar[out, '?];
FOR each: IagoOps.CommandList _ commandList, each.rest WHILE each # NIL DO
c: IagoOps.CommandInfo = each.first;
fullName: ROPE = c.fullName;
okWhenNoDisk: BOOL = c.okWhenNoDisk;
IF (diskReadable OR okWhenNoDisk)
AND Rope.Run[s1: fullName, s2: prefix, case: FALSE] = prefix.Length[]
THEN {
IF matches = none
THEN {
matches _ one;
uniqueLength _ Rope.Length[fullName];
found _ c;
IF end = '? THEN IO.PutRope[out, " ... one of:\n"];
}
ELSE {
stillMatches: INT =
Rope.Run[s1: fullName, s2: found.fullName, case: FALSE];
uniqueLength _ MIN[uniqueLength, stillMatches];
matches _ many;
IF end = '? THEN IO.PutRope[out, ", "];
};
IF end = '? THEN IO.PutRope[out, fullName];
};
ENDLOOP;
IF end = '? AND matches # none
THEN { IO.PutRope[out, prompt]; IO.PutRope[out, prefix] }
ELSE {
IF uniqueLength = prefix.Length[]
THEN {
SELECT matches FROM
none => IO.PutRope[out, " ... command not found"];
one => EXIT;
many => IF uniqueLength # 0 THEN IO.PutRope[out, " ... ambiguous"];
ENDCASE => ERROR;
IO.PutRope[out, prompt]; IO.PutRope[out, prefix];
}
ELSE {
extra: ROPE = Rope.Substr[
found.fullName, prefix.Length[], uniqueLength-prefix.Length[]];
IO.PutRope[out, extra];
SELECT matches FROM
one => EXIT;
many => prefix _ prefix.Cat[extra];
ENDCASE => ERROR;
};
};
ENDLOOP;
};

GetArg: PUBLIC PROC
[in, out: STREAM, prompt, default: ROPE, help: PROC] RETURNS [value: ROPE _ NIL] = {
DO
end: CHAR;
IO.PutRope[out, prompt];
IO.PutRope[out, value];
[id: value, c: end] _ GetID[in: in, out: out, default: default, init: value];
default _ NIL;
IF end = '? THEN help[] ELSE EXIT;
ENDLOOP;
};

Confirm: PUBLIC PROC[in, out: STREAM] RETURNS [BOOL] = {
DO c: CHAR = IO.GetChar[in];
SELECT c FROM
'y, 'Y, Ascii.CR => { IO.PutRope[out, "yes"]; RETURN [TRUE] };
'n, 'N => { IO.PutRope[out, "no"]; RETURN [FALSE] };
Ascii.DEL => ERROR Rubout[];
ENDCASE =>
IO.PutRope[out, "?\nConfirm by typing \"Y\" or CR, deny by typing \"N\", abort by typing DEL: "];
ENDLOOP;
};

ConfirmDestruction: PUBLIC PROC[in, out: STREAM, which: ROPE] RETURNS [BOOL] = {
IO.PutF[out, 
"\nThis operation will destroy all files on %g.\nAre you sure you want to do this? ",
[rope[which]] ];
RETURN [Confirm[in, out]]
};

GetNumber: PUBLIC PROC
[in, out: STREAM, default: INT, max: INT _ LAST[INT], prompt, help: ROPE]
RETURNS [size: INT _ 0] = {
Help: PROC = { IO.PutRope[out, help] };
sizeRope: ROPE _ Convert.RopeFromInt[default];
DO
sizeRope _ GetArg[ in: in, out: out, prompt: prompt, default: sizeRope, help: Help];
size _ 0;
FOR i: CARDINAL IN CARDINAL[0..sizeRope.Length[]) DO
c: CHAR = sizeRope.Fetch[i];
IF c IN ['0..'9]
THEN size _ size * 10 + (c-'0)
ELSE { IO.PutRope[out, " ... not a number"]; EXIT };
REPEAT FINISHED =>
IF size <= max
THEN RETURN
ELSE IO.PutF[out, " ... number should be less than %g", [integer[max]] ];
ENDLOOP;
ENDLOOP;
};

GetSize: PUBLIC PROC
[in, out: STREAM, default: INT, max: INT _ LAST[INT]] RETURNS [size: INT _ 0] = {
RETURN [GetNumber[
in, out, default, max,
"\nSize in pages: ", "? type the desired number of pages (in decimal)"]];
};

lastFile: ROPE _ NIL;
lastPattern: ROPE _ NIL;
lastDest: ROPE _ NIL;

GetFile: PUBLIC PROC[in, out: STREAM, prompt: ROPE _ NIL, extension: ROPE _ NIL, default: ROPE _ NIL, wDir: ROPE _ NIL, check: BOOL _ FALSE, pattern: BOOL _ FALSE] RETURNS [name: ROPE] = {
Help: PROC = {
IO.PutRope[out, "? type an FS file name"];
IF pattern THEN IO.PutRope[out, " (or pattern)"];
IO.PutRope[out, " such as \"[]<volume>a.b\" or \"[server]<directory>c.d\""];
};
name _ SELECT TRUE FROM
default # NIL => default,
pattern => lastPattern,
check => lastFile,
ENDCASE => lastDest;
DO
name _ GetArg[
in: in, out: out,
prompt: Rope.Cat["\n", prompt, "file name", IF pattern THEN " or pattern: " ELSE ": "],
default: name, help: Help];
IF name.Length[] = 0 THEN { Help[]; LOOP };
IF name.Find["."] < 0 AND extension.Length[] > 0
THEN { name _ name.Cat[extension]; IO.PutRope[out, extension] };
IF check OR pattern
THEN {
lastPattern _ name;
IF lastPattern.Find["*"] < 0 THEN lastFile _ lastPattern;
}
ELSE lastDest _ name;
IF check THEN {
name _ FS.FileInfo[name: name, wDir: wDir ! FS.Error => SELECT error.code FROM
$unknownServer, $unknownVolume, $unknownFile, $illegalName, $patternNotAllowed =>
{ IO.PutRope[out, " ... "]; IO.PutRope[out, error.explanation]; LOOP };
ENDCASE => NULL ].fullFName;
};
EXIT;
ENDLOOP;
};

GetSwitches: PUBLIC PROC[in, out: STREAM] RETURNS [switches: Booting.Switches] = {
RopeDefaultNil: TYPE = ROPE _ NIL;
switchTable: ARRAY GermSwap.Switch OF RopeDefaultNil _ [
zero: "worry-call debugger as early as possible",
one: "call debugger after MesaRuntime initialization",
two: "call debugger after VM initialization",
three: "call debugger after File initialization",
four: "call debugger after finding VM file and swapping in non-initial parts of boot file",
five: "call debugger in LoaderDriver after loading but before starting loadees",
a: "don't start Ethernet1 drivers",
b: "don't start Ethernet2 drivers",
c: "don't start Communication package",
d: "development version: don't try the Cedar directory in LoaderDriver/Installer",
f: "do full booting sequence, even if defaults would imply a rollback",
h: "hang in CPU loop with MP code instead of swapping to debugger",
i: "enable control-swat as early as possible (instead of waiting until after login)",
l: "long (and interactive) installation dialogue",
n: "don't touch the disk during initialization (forces entry to Iago)",
p: "don't read user profile from disk",
r: "rollback if the system volume has a valid checkpoint",
s: "use software safe storage ops instead of microcode",
t: "force teledebugging instead of disk world-swap",
v: "perform VM copying for checkpoint (internal use only!)",
w: "for world-swap debugger, assume debuggee outload file is valid/interesting"
];
value: ROPE _ NIL;
DO end: CHAR;
errors: BOOL _ FALSE;
FromChar: PROC[c: CHAR] = {
SELECT TRUE FROM
Ascii.Letter[c] => switches[VAL[GermSwap.Switch.a.ORD+(Ascii.Lower[c]-'a)]] _ TRUE;
Ascii.Digit[c] => switches[VAL[GermSwap.Switch.zero.ORD+(c-'0)]] _ TRUE;
ENDCASE => {
IO.PutRope[out, IF errors THEN ", " ELSE "\nUnrecognized switches: "];
IO.PutChar[out, c];
errors _ TRUE;
};
};
ToChar: PROC [sw: GermSwap.Switch] RETURNS [CHAR] = {
IF sw IN [zero..nine]
THEN RETURN ['0+sw.ORD]
ELSE RETURN ['A + (sw.ORD - GermSwap.Switch.a.ORD)]
};
IO.PutRope[out, "\nSwitches: "];
IO.PutRope[out, value];
[id: value, c: end] _ GetID[in: in, out: out, default: NIL, init: value];
IF end = '? THEN IO.PutChar[out, end];
switches _ ALL[FALSE];
FOR i: INT IN [0..value.Length[]) DO FromChar[value.Fetch[i]] ENDLOOP;
IF end = '?
THEN {
all: BOOL = value.Length[] = 0;
IF all THEN IO.PutRope[out, " Type one or more boot switches."];
IO.PutRope[out, "\nThe boot switches have the following meanings:"];
FOR sw: GermSwap.Switch IN GermSwap.Switch DO
IF (all AND switchTable[sw] # NIL) OR switches[sw] THEN {
IO.PutRope[out, "\n    "];
IO.PutChar[out, ToChar[sw]];
IO.PutRope[out, ": "];
IO.PutRope[out, IF switchTable[sw] = NIL
THEN "I don't know any meaning for this switch"
ELSE switchTable[sw]];
};
ENDLOOP;
}
ELSE { IF NOT errors THEN EXIT };
ENDLOOP;
};

clientVolName: PUBLIC ROPE _
IF File.SystemVolume[] = NIL THEN "Cedar" ELSE File.GetVolumeName[File.SystemVolume[]];

GetLogical: PUBLIC PROC
[in, out: STREAM, direction: ROPE _ NIL] RETURNS [v: File.Volume] = {
Help: PROC = {
first: BOOL _ TRUE;
IO.PutRope[out, "? one of:\n"];
FOR v: File.Volume _ File.NextVolume[NIL], File.NextVolume[v] UNTIL v = NIL DO
IF first THEN first _ FALSE ELSE IO.PutRope[out, ", "];
IO.PutRope[out, File.GetVolumeName[v ! File.Error => CONTINUE]];
ENDLOOP;
};
name: ROPE _ clientVolName;
DO
name _ GetArg[
in: in,
out: out,
prompt: Rope.Cat["\n", direction, "logical volume name: "],
default: name,
help: Help];
v _ File.FindVolumeFromName[name];
IF v # NIL THEN EXIT;
IO.PutRope[out, " ... that volume doesn't exist"];
ENDLOOP;
clientVolName _ name;
};

physVolName: ROPE _ NIL;

GetPhysical: PUBLIC PROC[in, out: STREAM] RETURNS [p: PhysicalVolume.Physical] = {
prompt: ROPE = "\nOn physical volume: ";
first: PhysicalVolume.Physical = PhysicalVolume.NextPhysical[NIL];
name: ROPE _ SELECT TRUE FROM
physVolName # NIL => physVolName,
first # NIL => PhysicalVolume.PhysicalInfo[first].name,
ENDCASE => NIL;
IF first # NIL AND PhysicalVolume.NextPhysical[first] = NIL
THEN {
IO.PutF[out, "%g%g", [rope[prompt]], [rope[PhysicalVolume.PhysicalInfo[first].name]] ];
p _ first;
}
ELSE {
Help: PROC = {
beginning: BOOL _ TRUE;
IO.PutRope[out, "? one of:\n"];
FOR p: PhysicalVolume.Physical _ first, PhysicalVolume.NextPhysical[p]
UNTIL p = NIL DO
thisName: ROPE;
channel: Disk.Channel;
rootStatus: PhysicalVolume.PhysicalRC;
[channel: channel, rootStatus: rootStatus, name: thisName] _
PhysicalVolume.PhysicalInfo[p];
IF beginning THEN beginning _ FALSE ELSE IO.PutRope[out, ", "];
IF rootStatus = ok
THEN IO.PutRope[out, thisName]
ELSE IO.PutF[out, "RD%g", [integer[Disk.DriveAttributes[channel].ordinal]] ];
ENDLOOP;
};
DO
name _ GetArg[
in: in,
out: out,
prompt: prompt,
default: name,
help: Help];
IF name.Length[] >= 3 -- RD0
AND Ascii.Upper[name.Fetch[0]] = 'R
AND Ascii.Upper[name.Fetch[1]] = 'D
THEN {
n: INT _ 0;
FOR i: CARDINAL IN CARDINAL[2..name.Length[]) DO
c: CHAR = name.Fetch[i];
IF c IN ['0..'9]
THEN n _ n * 10 + (c-'0)
ELSE GOTO noNumb;
ENDLOOP;
FOR p _ first, PhysicalVolume.NextPhysical[p] UNTIL p = NIL DO
IF Disk.DriveAttributes[PhysicalVolume.PhysicalInfo[p].channel].ordinal = n
THEN GOTO ok;
ENDLOOP;
EXITS noNumb => NULL;
};
FOR p _ first, PhysicalVolume.NextPhysical[p] UNTIL p = NIL DO
IF (PhysicalVolume.PhysicalInfo[p].name).Equal[name, FALSE] THEN GOTO ok;
ENDLOOP;
IO.PutRope[out, " ... that volume doesn't exist"];
ENDLOOP;
EXITS ok => physVolName _ name;
};
};

GetDrive: PUBLIC PROC[in, out: STREAM] RETURNS [d: Disk.Channel] = {
prompt: ROPE = "\nOn drive number: ";
first: Disk.Channel = Disk.NextChannel[NIL];
IF first # NIL AND Disk.NextChannel[first] = NIL
THEN {
IO.PutF[out, "%g%g", [rope[prompt]], [integer[Disk.DriveAttributes[first].ordinal]] ];
d _ first;
}
ELSE {
n: INT _ 0;
DO
n _ GetNumber[
in: in, out: out,
default: n,
prompt: prompt,
help: "? type the ordinal number of the physical disk drive (in decimal)"];
FOR d _ first, Disk.NextChannel[first] UNTIL d = NIL DO
IF Disk.DriveAttributes[d].ordinal = n THEN GOTO ok;
ENDLOOP;
IO.PutRope[out, " ... that drive doesn't exist"];
ENDLOOP;
EXITS ok => NULL;
};
};

FileError: PUBLIC PROC[why: File.RC] RETURNS [ROPE] = {
RETURN [SELECT why FROM
wentOffline => "volume is offline",
nonCedarVolume => "can't do that to a non-Cedar volume",
inconsistent => "the volume root page seems to be inconsistent",
software => "label-check: consult an expert",
hardware => "hard disk error: consult an expert",
unknownFile => "the file has been deleted",
unknownPage => "accessing beyond the end of the file",
volumeFull => "volume full",
fragmented => "the volume is too fragmented",
mixedDevices => "the file (or part of it) is on the wrong disk",
ENDCASE => "unknown File.Error: consult an expert"]
};

reserved: PhysicalVolume.Physical _ NIL;
interacted: BOOL _ FALSE; -- whether we've asked the user to pronounce on Alto regions
altoRegions: INT _ 0;

ReservePages: PUBLIC PROC[in, out: STREAM, p: PhysicalVolume.Physical] = {
IF Disk.DriveAttributes[PhysicalVolume.PhysicalInfo[p].channel].ordinal # 0
OR p = reserved
THEN RETURN;
[] _ CheckAltoRegions[in, out];
FileExtra.ReserveNoPages[p];
FileExtra.ReservePages[
physical: p, start: FormatDisk.hardUCodeStart, size: FormatDisk.hardUCodeSize];
FileExtra.ReservePages[
physical: p,
start: IF FormatDisk.altoRegionsBottomUp
THEN FormatDisk.altoRegionsStart
ELSE [FormatDisk.altoRegionsStart + FormatDisk.altoRegionsSize * (FormatDisk.altoRegionsMax - altoRegions)],
size: FormatDisk.altoRegionsSize * altoRegions];
reserved _ p;
};

CheckAltoRegions: PUBLIC PROC[in, out: STREAM] RETURNS [BOOL] = {
IF NOT interacted THEN ReserveAltoRegions[in, out];
RETURN [ altoRegions#0 ]
};

ReserveAltoRegions: PUBLIC PROC[in, out: STREAM] = {
reserved _ NIL;
interacted _ FALSE;
IF FormatDisk.altoRegionsMax <= 0
THEN altoRegions _ 0
ELSE
altoRegions _ GetNumber[
in: in,
out: out,
default: 0,
max: FormatDisk.altoRegionsMax,
prompt: Rope.Cat["
\nHow many Alto ",
FormatDisk.altoRegionJargon,
" do you want to have on drive RD0? "],
help: IO.PutFR["? type the desired number of %g, in the range [ 0 .. %g )",
[rope[FormatDisk.altoRegionJargon]], [integer[FormatDisk.altoRegionsMax]] ]
];
interacted _ TRUE;
};

NextRun: PUBLIC PROC
[d: Disk.Channel, origin: Disk.PageNumber]
RETURNS [firstPage: Disk.PageNumber, pageCount: Disk.PageCount-- -1 at end of disk --] = {
altoCount: Disk.PageCount = FormatDisk.altoRegionsSize * altoRegions;
altoStart: Disk.PageNumber = IF FormatDisk.altoRegionsBottomUp
THEN FormatDisk.altoRegionsStart
ELSE [FormatDisk.altoRegionsStart + FormatDisk.altoRegionsSize * (FormatDisk.altoRegionsMax - altoRegions)];
diskCount: Disk.PageCount = Disk.DriveAttributes[d].nPages;
IF origin >= diskCount THEN RETURN [origin, -1];
IF Disk.DriveAttributes[d].ordinal # 0 THEN RETURN [origin, diskCount-origin];
firstPage _ origin;
IF firstPage >= altoStart
AND firstPage <= altoStart + altoCount
THEN firstPage _ [altoStart + altoCount];
pageCount _ diskCount-firstPage;
IF firstPage < altoStart
AND firstPage+pageCount > altoStart
THEN pageCount _ altoStart-firstPage;
};

--File.--VolumeID: PUBLIC TYPE = IagoOps.VolumeID;

NewID: PUBLIC PROC RETURNS [new: VolumeID] = {
id: RECORD[a,b,c: CARDINAL] = LOOPHOLE[ProcessorFace.processorID];
new.a _ id.a;
new.b _ id.b;
new.c _ id.c;
new.t _ BasicTime.ToNSTime[BasicTime.Now[]];
};

PutID: PUBLIC PROC[out: STREAM, id: VolumeID] = {
IO.PutF[out, "[%xH,%xH,%xH,%bB]",
[cardinal[id.a]],
[cardinal[id.b]],
[cardinal[id.c]],
[cardinal[id.t]]
];
};

InitialMicrocodeFileName: PUBLIC PROC RETURNS [ROPE] = {
shortName: ROPE _ "InitialUnknown.eb";
SELECT SystemVersion.machineType FROM
dolphin => shortName _ "InitialPilotD0.eb";
dorado => shortName _ IF isDiskReadable THEN "InitialDiskDorado.eb" ELSE
		"InitialEtherAltoMesaDorado.eb";
dandelion => shortName _ "InitialDiskDLion.db";
dicentra => shortName _ "InitialEtherDicentra.eb";
ENDCASE;
RETURN [Rope.Cat[DefaultRemoteNames.Get[].current, "Top>", shortName]];
};

RemoteRootFileName: PUBLIC PROC
[which: File.VolumeFile[checkpoint..bootFile]] RETURNS [ROPE] = {
machine: ROPE = SELECT SystemVersion.machineType FROM
dolphin => "D0",
dorado => "Dorado",
dandelion => "DLion",
dicentra => "Dicentra",
ENDCASE => "Unknown";
dir: ROPE = Rope.Cat[DefaultRemoteNames.Get[].current, "Top>"];
RETURN [SELECT which FROM
checkpoint => NIL,
microcode => Rope.Cat[dir, "Cedar", machine, ext[which]],
germ => Rope.Cat[dir, machine, ext[which]],
bootFile => Rope.Cat[dir, "BasicCedar", machine, ext[which]],
ENDCASE => ERROR]
};

LocalRootFileName: PUBLIC PROC[which: File.VolumeFile] RETURNS [ROPE] = {
RETURN [Rope.Cat[
SELECT which FROM
checkpoint => "Checkpoint",
microcode => "Microcode",
germ => "Germ",
bootFile => "BootFile",
debugger => "Debugger",
debuggee => "Debuggee",
VM => "VM",
VAM => "VAM",
client => "FS",
alpine => "Alpine",
ENDCASE => ERROR, ".DontDeleteMe"] ]
};

ext: PUBLIC ARRAY File.VolumeFile[checkpoint..bootFile] OF ROPE _ [
checkpoint: ".outload",
microcode: SELECT SystemVersion.machineType FROM
dandelion, dicentra => ".db",
ENDCASE => ".eb",
germ: ".germ",
bootFile: ".boot"];

WriteRemoteNames: PUBLIC PROC
[volume: ROPE, systemHost,userHost: ROPE, out: STREAM] RETURNS [success: BOOL]= {
ENABLE FS.Error => {
IO.PutF[out, "\nSorry, default names not saved:\n  %g\n", [rope[error.explanation]] ];
GO TO noWrite;
};
fileName: ROPE = Rope.Cat["[]<", volume, ">RemoteNames.DontDeleteMe"];
stream: STREAM = FS.StreamOpen[fileName, create];
remoteNames: DefaultRemoteNames.DefaultNames = DefaultRemoteNames.Get[];
IF systemHost = NIL THEN systemHost _ remoteNames.systemHost;
IF userHost = NIL THEN userHost _ remoteNames.userHost;
IO.PutF[stream, "%g\n%g\n", [rope[systemHost]], [rope[userHost]] ];
FOR each: FSPseudoServers.PseudoServerList _ FSPseudoServers.GetPseudoServers[], each.rest WHILE each # NIL DO
IO.PutRope[stream, FSPseudoServersExtra.RopeFromPseudoServer[each]];
IO.PutRope[stream, "\n"];
ENDLOOP;
IO.Close[stream];
IO.PutF[out, "\nHost names saved to %g\n", [rope[fileName]]];
RETURN [TRUE];
EXITS noWrite => {RETURN [FALSE]};
};

ReadRemoteNames: PUBLIC PROC [volume: ROPE] RETURNS [success: BOOL] = {
fileName: ROPE = Rope.Cat["[]<", volume, ">RemoteNames.DontDeleteMe"];
remoteNamesStream: STREAM = FS.StreamOpen[fileName ! FS.Error => GO TO useDefault];
systemHost: ROPE = GetToken[remoteNamesStream ! IO.EndOfStream => GO TO useDefault];
userHost: ROPE = GetToken[remoteNamesStream ! IO.EndOfStream => GO TO useDefault];
IF systemHost # NIL AND userHost # NIL THEN {
remoteNames: DefaultRemoteNames.DefaultNames = DefaultRemoteNames.Get[];
remoteNames.systemHost _ systemHost;
remoteNames.userHost _ userHost;
remoteNames.current _ Rope.Replace[
remoteNames.current, 0, Rope.SkipTo[remoteNames.current, 0, "]" ]+1, systemHost];
[] _ IO.GetLineRope[remoteNamesStream ! IO.EndOfStream => CONTINUE];
DO
line: ROPE _ IO.GetLineRope[remoteNamesStream ! IO.EndOfStream => EXIT];
new: FSPseudoServers.PseudoServerList _ FSPseudoServersExtra.PseudoServerFromRope[line].new;
IF new = NIL THEN EXIT;
FSPseudoServersExtra.InsertPseudoServer[new];
ENDLOOP;
IF FSPseudoServersExtra.Lookup["Cedar"] = NIL THEN {
len: INT _ Rope.Length[systemHost];
stripped: ROPE _ Rope.Substr[systemHost, 1, len-2];
FSPseudoServersExtra.InsertPseudoServer[
FSPseudoServersExtra.PseudoServerFromRope[
Rope.Concat["Cedar $ ", stripped]
].new];
};
};
IO.Close[remoteNamesStream];
RETURN [TRUE];
EXITS useDefault => RETURN [FALSE];
};

GetToken: PROC [st: STREAM] RETURNS [token: ROPE _ NIL] = {
token _ IO.GetTokenRope[st, IO.IDProc ! IO.EndOfStream => CONTINUE].token;
};

TRUSTED{ FormatDisk.Start[] };

END.
>IagoOpsImpl.mesa - Iago user interface subroutines
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Birrell, December 7, 1983 10:51 am
Levin, September 22, 1983 1:32 pm
Russ Atkinson, January 2, 1985 5:02:30 pm PST
Willie-Sue, August 13, 1984 10:30:29 am PDT

********        Input subroutines        ********
text to be backed up is of the form ...<non-alpha><alpha><non-alpha>, the <alpha> and following <non-alpha> are to be removed.
... registers the command with Iago so it can be found again.  This allows external programs to register commands as well.
Insert new command
Replace old command
May raise Rubout
Defaults for "GetFile":
Get to here if it's not in RDn format, or if that didn't find a volume
First find a starting point outside reserved areas
IF firstPage >= FormatDisk.hardUCodeStart
AND firstPage <= FormatDisk.hardUCodeStart + FormatDisk.hardUCodeSize
THEN firstPage _ [FormatDisk.hardUCodeStart + FormatDisk.hardUCodeSize];
Then find how many pages we can manage
IF firstPage < FormatDisk.hardUCodeStart
AND firstPage+pageCount > FormatDisk.hardUCodeStart
THEN pageCount _ FormatDisk.hardUCodeStart-firstPage;
Set the remote names from the file contents.
This is a standard name that we need to define via the default system host.  We define it to be a simple readonly translation to the system host.
Κ˜š
œ2™2Jšœ
Οm
œ1™<Jš
œ"™"J™!J™-J™+—J™
codeš
Οk	˜	Kšœžœžœ*žœžœžœ	˜cKšœ
žœ˜ Kšœžœ˜Kšœžœ˜Kšœžœ˜-Kšœžœ@˜JKšœžœ8žœ.˜rKšœ
žœ ˜/Kšœžœ‚
˜’
Kšžœ
žœ˜'Kšœžœ&˜;KšœžœJ˜dKšœ	žœ
˜Kšœžœ&˜3Kšžœ
žœlžœ˜|Kšœžœ4˜HKšœžœ˜"Kšœžœ>žœ ˜lKšœžœ˜"—J˜šœ
žœ
ž˜KšžœSžœ)žœ4˜»
KšžœΟcœ	˜!Kšœž˜K˜Kšžœžœžœ
˜Kšžœžœžœ
žœ
˜—˜J˜—Jš
œ1™1˜Jšœžœ
žœžœ
˜J˜šΟnœžœ
ž˜Jš
œ
žœžœžœžœžœžœ
˜EJšžœžœžœ˜Jšžœ˜Jšœžœ
žœ
˜š œžœ˜šžœž˜Jšžœžœ
ž
œ
žœžœžœ
˜Q—Jšœžœ
˜	J˜—š œžœžœžœžœžœ˜.šžœžœ˜šžœž˜
Jšœ
žœ žœžœžœžœ
˜@Jšžœ˜—Jšœžœ
˜Jš
œ˜—Jš
žœžœ
žœžœ
žœ˜#J˜—J˜Jšžœžœ
žœ˜&Jšœžœ
˜šžœ	ž˜šžœž˜
Jšžœžœ˜šœ
žœ˜Jšœžœ˜šžœ	žœ˜J˜Jšžœžœ˜*Jš
œ˜Jš
œ˜—J˜—š
œ˜Jš
œ~™~Jšœžœžœ
˜š	žœžœ
ž
œ
žœž˜,Jšœžœ˜Jšžœžœžœ	ž˜8Jšžœ
žœžœžœ˜6Jšžœžœ˜š
ž˜Jšžœ	žœ
˜—Jšžœ
˜—J˜—Jš
œ˜Jšžœ$žœžœ
žœ˜L—Jšœžœ
˜Jšžœ
˜—Jš
œ˜J˜—Jšœ#žœ
˜'J˜š œžœ
žœ ˜<Jš
œz™zJšœžœ˜&Jšœžœ
˜šžœ4žœžœ
ž˜JJšœžœ˜!šžœ#žœž˜4š
œ	˜	Jš
œ™Jš
œ˜Jšžœ
˜J˜—˜
Jš
œ™Jš
œ˜Jšžœ
˜J˜—Jšžœ
˜—J˜Jšžœ
˜—Jšžœžœ
žœžœ˜8J˜J˜—š œžœ
žœ
žœ˜=Jšžœ˜J˜—J˜Jšœžœžœ
˜š 
œžœ
ž˜Jšœ
žœžœžœ!˜NJš
œ™Jšœžœ˜Jšœžœžœžœ
˜Jšœžœžœ
˜Jš
œ˜Jšžœ˜š
ž˜Jšœžœ
˜
J˜$Jšœžœ
˜Jšœ8žœ˜KJš
œ˜Jšžœ
žœ
žœ˜%šžœ4žœžœ
ž˜JJš
œ$˜$Jšœ
žœ˜Jšœžœ˜$šžœžœ˜!Jšžœ*žœ˜Ešžœ˜šžœ˜šžœ˜Jš
œ˜Jš
œ%˜%Jš
œ
˜
Jšžœ
žœ
žœ ˜3Jš
œ
˜
—šžœ˜šœžœ˜Jšœ1žœ˜8—Jšœžœ˜/Jš
œ˜Jšžœ
žœ
žœ˜'Jš
œ˜——Jšžœ
žœ
žœ˜+Jš
œ˜——Jšžœ
˜—šžœ
žœ˜Jšžœžœžœ˜9šžœ˜šžœ˜!šžœ˜šžœ	ž˜Jšœžœ(˜2Jšœžœ
˜Jšœžœžœ
žœ ˜CJšžœžœ
˜—Jšžœžœ˜1Jš
œ
˜
—šžœ˜šœžœ˜Jš
œ?˜?—Jšžœ˜šžœ	ž˜Jšœžœ
˜Jš
œ#˜#Jšžœžœ
˜—Jš
œ˜——Jš
œ˜——Jšžœ
˜—Jš
œ˜—J˜š œžœ
ž˜Jš
œ
žœžœžœžœ	žœžœ˜Tš
ž˜Jšœžœ
˜
Jšžœ˜Jšžœ˜J˜MJšœ
žœ
˜Jšžœ
žœžœ
žœ
˜"Jšžœ
˜—Jš
œ˜—J˜š œžœ
žœ
žœžœžœ˜8šžœžœžœ
˜šžœž˜
Jš	œžœžœžœžœ˜>Jšœžœžœžœ˜4Jšœžœžœ
˜šžœ˜
Jšžœ_˜a——Jšžœ
˜—Jš
œ˜—J˜š œžœ
žœ
žœ	žœžœžœ˜Pšžœ˜
Jš
œU˜UJš
œ˜—Jšžœ˜Jš
œ˜—J˜š 	œžœ
ž˜Jš
œ
žœžœžœžœ
žœžœ
˜IJšžœžœ	˜Jš œžœžœ˜'Jšœ
žœ ˜.š
ž˜Jš
œT˜TJš
œ	˜	š	žœžœ
žœ
žœž˜4Jšœžœ˜šžœžœ	˜Jšžœ˜Jšžœžœ$žœ˜4—šžœ
žœ˜šžœ˜Jšžœ
ž˜Jšžœ
žœB˜I——Jšžœ
˜—Jšžœ
˜—Jš
œ˜—J˜š œžœ
ž˜Jšœ
žœžœžœžœ
žœžœžœ	˜Qšžœ˜Jš
œ˜Jš
œI˜I—Jš
œ˜—J˜š
œ™Jšœ
žœžœ
˜Jšœ
žœžœ
˜Jšœ
žœžœ
˜—J˜š$ œžœ
žœ
žœ
žœžœ
žœžœžœžœžœžœ	žœžœžœžœ
žœžœ˜Ό
š œžœ˜Kšžœ(˜*Kšžœ	žœ
žœ˜1KšžœJ˜LKš
œ˜—šœžœ
žœ
ž˜Kšœ
žœ˜Kš
œ˜Kš
œ˜Kšžœ
˜—š
ž˜š
œ˜K˜Kšœ,žœ	žœžœ˜WKš
œ˜—Kšžœžœžœ˜+šžœžœ˜0Kšžœžœ˜@—šžœžœ˜šžœ˜Kš
œ˜Kšžœžœ˜9Kš
œ
˜
—Kšžœ˜—šžœžœ˜Kšœžœ#žœ
žœž˜Nš
œQ˜QKšœžœžœ"žœ˜G—Kšžœžœ
˜Kš
œ˜—Kšžœ
˜Kšžœ
˜—Kš
œ˜—J˜š
 œžœ
žœ
žœžœ!˜RJšœžœžœžœ
˜"šœ
žœžœ˜8J˜1J˜6J˜-J˜1J˜[J˜PJ˜#J˜#J˜'J˜RJ˜GJ˜CJ˜UJ˜2J˜GJ˜'J˜:J˜8J˜4J˜<J˜OJ˜—Jšœžœžœ
˜šžœžœ
˜
Jšœžœžœ
˜š œžœžœ˜šžœ
žœ
ž˜Jšœžœžœžœ
˜SJšœžœžœžœ
˜Hšžœ˜Jšžœžœžœžœ˜FJšžœ˜Jšœ	žœ
˜Jš
œ˜——Jš
œ˜—š œžœžœžœ˜5šžœžœ
˜Jšžœ
žœžœ
˜Jšžœ
žœžœžœ˜3—Jš
œ˜—Jšžœ˜ Jšžœ˜Jšœ7žœ˜IJšžœ
žœ
žœ˜&Jšœžœ
žœ˜Jš
žœžœ
žœžœžœ
˜Fšžœ	˜šžœ˜Jšœžœ˜Jšžœžœ
žœ2˜@JšžœB˜Dšžœžœž˜-š
žœžœžœžœžœ˜9Jšžœ˜Jšžœ˜Jšžœ˜šžœžœž˜(Jšžœ+˜/Jšžœ˜—Jš
œ˜—Jšžœ
˜—Jš
œ
˜
—Jš
žœžœ
žœžœ
žœ˜!——Jšžœ
˜Jš
œ˜—J˜šœžœ
žœ˜Jšžœžœ
žœ	žœ)˜W—J˜š 
œžœ
ž˜Jš	œ
žœ
žœžœžœ˜Eš œžœ˜Jšœžœžœ
˜Jšžœ˜š	žœ"žœžœžœ
ž˜NJš
žœžœ	žœ
žœ
žœ˜7Jšžœ3žœ˜@Jšžœ
˜—Jš
œ˜—Jšœžœ˜š
ž˜š
œ˜J˜J˜	J˜;Jš
œ˜J˜—J˜"Jšžœžœ
žœ
žœ
˜Jšžœ0˜2Jšžœ
˜—Jš
œ˜Jš
œ˜—J˜Jšœ
žœžœ
˜J˜š
 œžœ
žœ
žœžœ!˜RJšœžœ˜(Jšœ=žœ˜Bšœžœžœ
žœ
ž˜Jšœžœ˜!Jšœžœ,˜7Jšžœžœ
˜—šžœ	žœ
žœ&ž˜;šžœ˜JšžœU˜WJ˜
Jš
œ
˜
—šžœ˜š œžœ˜Jšœžœžœ
˜Jšžœ˜šžœC˜FJšžœžœ
ž˜Jšœ
žœ
˜Jš
œ˜Jš
œ&˜&š
œ<˜<Jš
œ˜—Jš
žœžœ
žœ
žœ
žœ˜?Jšžœ˜Jšžœ
žœ˜Jšžœ
žœF˜MJšžœ
˜—Jš
œ˜—š
ž˜š
œ˜J˜J˜	Jš
œ˜Jš
œ˜J˜—šžœŸ˜Jšžœ ˜#Jšžœ ˜#šžœ˜Jšœžœ˜š	žœžœ
žœ
žœž˜0Jšœžœ˜šžœžœ	˜Jšžœ˜Jšžœ
žœ˜—Jšžœ
˜—šžœ+žœžœ
ž˜>šžœI˜KJšžœ
žœ˜
—Jšžœ
˜—Jšžœžœ
˜Jš
œ˜——Jš
œF™Fšžœ+žœžœ
ž˜>Jšžœ3žœžœ
žœ˜IJšžœ
˜—Jšžœ0˜2Jšžœ
˜—Jšžœ˜Jš
œ˜——Jš
œ˜—J˜š
 œžœ
žœ
žœžœ˜DJšœžœ˜%Jšœ'žœ˜,šžœ	žœ
žœž˜0šžœ˜JšžœT˜VJ˜
Jš
œ
˜
—šžœ˜Jšœžœ˜š
ž˜š
œ˜J˜J˜Jš
œ˜J˜K—šžœ$žœžœ
ž˜7Jšžœ%žœ
žœ˜4Jšžœ
˜—Jšžœ/˜1Jšžœ
˜—Jšžœžœ
˜Jš
œ˜——Jš
œ˜—J˜š 	œžœ
žœžœžœžœ˜7šžœžœž˜Jš
œ#˜#Jš
œ8˜8Jš
œ@˜@Jš
œ-˜-Jš
œ1˜1J˜+J˜6J˜Jš
œ-˜-J˜@Jšžœ,˜3—Jš
œ˜—J˜Jšœ$žœ
˜(JšœžœžœŸ<˜VJšœ
žœ˜J˜š œžœ
žœ
žœ!˜JšžœI˜KJšžœ
˜Jšžœ
žœ
˜—Jš
œ˜Jš
œ˜š
œ˜Jš
œO˜O—š
œ˜Jš
œ˜šœžœ˜(Jšžœ˜ Jšžœh˜l—Jš
œ0˜0—Jš
œ
˜
Jš
œ˜—J˜š œžœ
žœ
žœžœžœ˜AJšžœ
žœžœ˜3Jšžœ˜Jš
œ˜—J˜š œžœ
žœ
žœ˜4Jšœžœ
˜Jšœ
žœ
˜šžœ˜!Jšžœ˜š
ž˜š
œ˜J˜J˜	J˜Jš
œ˜š
œ˜Jš
œ˜Jš
œ˜Jš
œ'˜'—šœžœC˜KJš
œK˜K—J˜———Jšœ
žœ
˜Jš
œ˜—J˜š œžœ
ž˜Jš
œ*˜*Jšžœ7Ÿœ˜ZJš
œE˜Ešœžœ˜>Jšžœ˜ Jšžœh˜l—Jš
œ;˜;Jšžœžœ
žœ˜0Jšžœ%žœ
žœ˜NJš
œ2™2Jš
œ˜šžœ˜Jšžœ#˜&Jšžœ%˜)—š
œ)™)Jš
œE™EJš
œH™H—Jš
œ&™&Jš
œ ˜ šžœ˜Jšžœ ˜#Jšžœ!˜%—š
œ(™(Jš
œ3™3Jš
œ5™5—Jš
œ˜—J˜JšŸ	œ
žœ
žœ˜2J˜š œžœ
žœ
žœ˜.Jšœžœžœžœ˜BJš
œ
˜
Jš
œ
˜
Jš
œ
˜
J˜,Jš
œ˜—J˜š œžœ
žœžœ˜1šžœ˜!J˜J˜J˜J˜J˜—Jš
œ˜—J˜š
 œžœ
žœ
žœžœ˜8Jšœžœ˜&šžœž˜%Jš
œ+˜+šœžœžœž˜HJš
œ"˜"—Jš
œ/˜/Jš
œ2˜2Jšžœ
˜—JšžœA˜GJš
œ˜—J˜š œžœ
ž˜Jšœ/žœžœ˜Ašœ	žœžœž˜5J˜J˜J˜J˜Jšžœ˜—Jšœžœ6˜?šžœžœž˜Jšœžœ
˜Jš
œ9˜9Jš
œ+˜+Jš
œ=˜=Jšžœžœ
˜—Jš
œ˜—J˜š
 œžœ
žœžœžœ˜Išžœ˜šžœž˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜J˜J˜Jšžœ	˜Jšžœ
˜
J˜J˜—Jšžœžœ˜$—Jš
œ˜—J˜š	œžœ
žœ'žœ
žœ˜CJš
œ˜šœžœž˜0Jš
œ˜Jšžœ
˜—Jš
œ˜Jš
œ˜J˜—š œžœ
ž˜Jšœ	žœžœžœžœžœ˜Qšžœ
žœ˜šžœT˜VJšžœ
žœ	˜J˜——Jšœ
žœ8˜FJšœžœžœ˜1Jš
œH˜HJšžœžœ
žœ%˜=Jšžœžœ
žœ!˜7JšžœA˜CšžœXžœžœ
ž˜nJšžœB˜DJšžœ˜Jšžœ
˜—Jšžœ˜Jšžœ;˜=Jšžœžœ˜Jšžœ
žœžœ˜"J˜J˜—š œžœ
žœ
žœžœžœ˜GKšœ
žœ8˜FKšœžœžœžœ
žœ
žœ
˜SKšœžœ žœ
Οrœžœ
žœ
˜TKšœ
žœ žœ
‘œžœ
žœ
˜Rš
žœžœ
žœžœ
žœ˜-Kš
œ,™,Kš
œH˜HKš
œ$˜$Kš
œ ˜ š
œ#˜#Kš
œQ˜Q—Kš	œžœ!žœ
‘œžœ˜Dš
ž˜Kšœžœžœ!žœ
‘œžœ˜HKš
œ\˜\Kšžœžœ
žœ
žœ
˜Kš
œ-˜-Kšžœ
˜—šžœ(žœ
žœ˜4Kš
œ‘
™‘
Kšœžœ˜#Kšœ
žœ%˜3š
œ(˜(š
œ*˜*K˜!—Kš
œ˜—K˜—K˜—Kšžœ˜Kšžœžœ˜Kšžœžœžœ˜#K˜K˜—š œžœžœžœ	žœžœ˜;Jš	œžœžœ
žœžœ˜JJ˜—J˜Jšžœ˜J˜—Jšžœ
˜—…—U\wœ