DIRECTORY
Atom USING [GetPName],
BasicTime USING [GetClockPulses, GMT, Now, Period, Pulses, PulsesToMicroseconds],
Buttons USING [Button, ButtonProc, Create, Destroy, SetDisplayStyle],
Commander USING [CommandProc, Register],
Containers USING [ChildXBound, ChildYBound, Create],
Convert USING [Error, IntFromRope, RopeFromInt],
IO USING [Flush, PutChar, PutF, PutRope, STREAM, Value],
Labels USING [Create],
Loader USING [BCDBuildTime],
PupDefs USING [GetFreePupBuffer, GetHostName, GetPupAddress, GetPupContentsBytes, MsToTocks, PupAddress, PupBuffer, PupAddressToRope, PupNameTrouble, PupRouterSendThis, PupSocket, PupSocketDestroy, PupSocketKick, PupSocketMake, ReturnFreePupBuffer, ReturnPup, SetPupContentsBytes, SwapPupSourceAndDest, veryLongWait],
PupTypes USING [echoSoc, fillInPupAddress, fillInSocketID, maxDataBytesPerGatewayPup],
Rope USING [ROPE],
Rules USING [Create],
TypeScript USING [ChangeLooks, Create],
ViewerClasses USING [Viewer],
ViewerEvents USING [EventProc, RegisterEventProc],
ViewerIO USING [CreateViewerStreams],
ViewerOps USING [AddProp, ComputeColumn, CreateViewer, FetchProp, MoveViewer, OpenIcon, SetOpenHeight],
ViewerTools USING [GetContents, MakeNewTextViewer, SetContents, SetSelection],

DriverDefs USING [GetDeviceChain, Network],
EthernetDriverStats USING [EtherStats, MaxTries],
PupEchoServerDefs USING [echoStatsReply, echoStatsRequest, EchoStatsEntry, echoVersion],
PupRouterDefs USING [EnumerateRoutingTable, RoutingTableEntry],
PupWireFormat USING [MesaToBcplLongNumber];

EchoTool: CEDAR MONITOR
IMPORTS
Atom, BasicTime, Buttons, Commander, Containers, Convert, IO, Labels, Loader, PupDefs, Rules, TypeScript, ViewerEvents, ViewerIO, ViewerOps, ViewerTools,
DriverDefs, PupRouterDefs, PupWireFormat =
BEGIN

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

buttonHeight: INTEGER _ 0;
buttonWidth: INTEGER _ 0;

pupsEchoed: INT _ 0;
serverLog: STREAM _ NIL;
pleaseStopServer: BOOLEAN _ FALSE;
server: PROCESS _ NIL;
showDollar: REF BOOL _ NEW [BOOL _ FALSE];
serverSoc: PupDefs.PupSocket _ NIL;

ClientData: TYPE = REF ClientDataRep;
ClientDataRep: TYPE = RECORD [
log: STREAM _ NIL,
in: STREAM _ NIL,
pleaseStop: BOOLEAN _ FALSE,
user: PROCESS _ NIL,
where: PupDefs.PupAddress _ PupTypes.fillInPupAddress,
echo: REF BOOL _ NEW [BOOL _ TRUE],
miss: REF BOOL _ NEW [BOOL _ TRUE],
late: REF BOOL _ NEW [BOOL _ TRUE],
dataChecking: REF BOOL _ NEW [BOOL _ TRUE],
fixedLength: REF BOOL _ NEW [BOOL _ FALSE],
target, length, delay, pause: Viewer _ NIL,
good: INT _ 0,
minDelay, maxDelay: INT _ 0,
delayHist: ARRAY DelayRange OF INT _ ALL[0] ];

DelayRange: TYPE = {
d1, d1a, d2, d2a, d3, d3a, d4, d4a, d5, d5a, d6, d6a, d7, d7a, d8, d8a, d9, d9a, 
d10, d14, d20, d28, d50, d70, d100, d140, d200, d280, d500, d700,
d1000, d1400, d2000, d2800, d5000, d7000, d10000, d14000, d20000, d28000, more};

delayTime: ARRAY DelayRange OF INT = [
d1: 1000, d1a: 1500, d2: 2000, d2a: 2500,
d3: 3000, d3a: 3500, d4: 4000, d4a: 4500,
d5: 5000, d5a: 5500, d6: 6000, d6a: 6500,
d7: 7000, d7a: 7500, d8: 8000, d8a: 8500,
d9: 9000, d9a: 9500,
d10: 10000, d14: 14000, d20: 20000, d28: 28000, d50: 50000, d70: 70000,
d100: 100000, d140: 140000, d200: 200000, d280: 280000, d500: 500000, d700: 700000,
d1000: 1000000, d1400: 1400000, d2000: 2000000, d2800: 2800000, d5000: 5000000, d7000: 7000000,
d10000: 10000000, d14000: 14000000, d20000: 20000000, d28000: 28000000, more: LAST[INT]];

global: ClientData _ NIL;  -- debugging
Create: Commander.CommandProc = TRUSTED {
viewer, buttons, log: Viewer _ NIL;
data: ClientData _ NEW[ClientDataRep _ []];
global _ data;
viewer _ ViewerOps.CreateViewer [
flavor: $Container,
info: [name: "EchoTool", column: right, iconic: TRUE, scrollable: FALSE]]; 
[] _ ViewerEvents.RegisterEventProc[Poof, destroy, viewer, TRUE];
ViewerOps.AddProp[viewer, $PupEcho, data];
{ -- Kludge to find Button size
temp: Buttons.Button = Buttons.Create[
info: [name: "Length:", parent: viewer, border: FALSE,
wx: 0, wy: 0],
proc: NIL, clientData: NIL, fork: FALSE, paint: FALSE];
buttonWidth _ temp.ww;
buttonHeight _ temp.wh;
Buttons.Destroy[temp]; };
log _ TypeScript.Create[
[name: "EchoTool.log", wy: 27+4, parent: viewer, border: FALSE], FALSE];
[data.in, data.log] _ ViewerIO.CreateViewerStreams [
name: "EchoTool.log", backingFile: "EchoTool.log", viewer: log, editedStream: FALSE];
IF serverLog = NIL THEN { serverLog _ data.log; StartServer[]; };
Containers.ChildXBound[viewer, log];
Containers.ChildYBound[viewer, log];
CreateButtons[data, viewer, log];
TypeScript.ChangeLooks[log, 'f];
IO.PutF[data.log, "EchoTool of %G.\n", [time[Loader.BCDBuildTime[Create]]]];
ViewerOps.OpenIcon[viewer]; }; 

CreateButtons: ENTRY PROC[data: ClientData, parent, log: Viewer] = {
child: Viewer _ NIL;
kids: Viewer = Containers.Create[
info: [parent: parent, border: FALSE, scrollable: FALSE, wx: 0, wy: -9999, ww: 9999, wh: 0] ];
Containers.ChildXBound[parent, kids];
child _ MakeBool[name: "!", init: data.echo, clientData: data, parent: kids, x: 2, y: 1];
child _ MakeBool[name: "?", init: data.miss, clientData: data, parent: kids, x: child.wx + child.ww + 10, y: child.wy];
child _ MakeBool[name: "#", init: data.late, clientData: data, parent: kids, x: child.wx + child.ww + 10, y: child.wy];
child _ MakeBool[name: "$", init: showDollar, clientData: data, parent: kids, x: child.wx + child.ww + 10, y: child.wy];
child _ MakeBool[name: "D-ck", init: data.dataChecking, clientData: data, parent: kids, x: child.wx + child.ww + 10, y: child.wy];
child _ MakeBool[name: "FixedLength", init: data.fixedLength, clientData: data, parent: kids, x: child.wx + child.ww + 10, y: child.wy];
child _ data.length _ MakeLabeledText[
parent: kids,
sibling: child,
name: "Length:",
data: Convert.RopeFromInt[PupTypes.maxDataBytesPerGatewayPup],
prev: data.length,
newline: FALSE ];
child _ MakeRule[kids, child];
child _ data.target _ MakeLabeledText[
parent: kids,
sibling: child,
name: "Target:",
data: "
Target",
prev: data.target ];
child _ MakeRule[kids, child];
child _ MakeLabel[kids, child, "What:"];
child _ MakeButton[kids, child, data, "Poke", PokeProc];
child _ MakeButton[kids, child, data, "Start", StartProc];
child _ MakeButton[kids, child, data, "Hist", HistProc];
child _ MakeButton[kids, child, data, "Stop", StopProc];
child _ MakeButton[kids, child, data, "Route", RouteProc];
child _ MakeButton[kids, child, data, "Stats", StatsProc];
child _ MakeRule[kids, child];
{
kidsY: INTEGER = 2;
kidsH: INTEGER = child.wy + child.wh + 2;
ViewerOps.MoveViewer[viewer: log, x: 0, y: kidsY + kidsH, w: log.ww, h: parent.ch - (kids.wy + kidsH), paint: FALSE];
ViewerOps.SetOpenHeight[parent, kidsY + kidsH + 12 * buttonHeight];
IF ~parent.iconic THEN ViewerOps.ComputeColumn[parent.column];
ViewerOps.MoveViewer[viewer: kids, x: kids.wx, y: kidsY, w: kids.ww, h: kidsH]; };
};

Poof: ViewerEvents.EventProc = {
data: ClientData _ NARROW[ViewerOps.FetchProp[viewer, $PupEcho]];
IF event # destroy OR before # TRUE THEN ERROR;
Stop[data];
IF data.log = serverLog THEN StopServer[]; };

StartServer: ENTRY PROC = {
IF server # NIL THEN RETURN;
pleaseStopServer _ FALSE;
server _ FORK Server[]; };

StopServer: ENTRY PROC = TRUSTED {
IF server = NIL THEN RETURN;
pleaseStopServer _ TRUE;
IF server # NIL THEN {PupDefs.PupSocketKick[serverSoc]; JOIN server; };
server _ NIL; };

Server: PROC = TRUSTED {
serverSoc _ PupDefs.PupSocketMake[
PupTypes.echoSoc, PupTypes.fillInPupAddress, PupDefs.veryLongWait];
UNTIL pleaseStopServer DO
b: PupDefs.PupBuffer _ serverSoc.get[];
IF b # NIL THEN {
SELECT b.pupType FROM
echoMe => {
b.pupType _ iAmEcho;
PupDefs.SwapPupSourceAndDest[b];
PupDefs.PupRouterSendThis[b];
pupsEchoed _ pupsEchoed.SUCC;
IF showDollar^ THEN IO.PutChar[serverLog, '$]; };
PupEchoServerDefs.echoStatsRequest => {
EchoStatsEntry: TYPE = PupEchoServerDefs.EchoStatsEntry;
ese: LONG POINTER TO EchoStatsEntry _ LOOPHOLE[@b.pupWords];
ese^ _ [
version: PupEchoServerDefs.echoVersion,
pupsEchoed: PupWireFormat.MesaToBcplLongNumber[pupsEchoed]];
PupDefs.ReturnPup[
b, PupEchoServerDefs.echoStatsReply, 2*SIZE[EchoStatsEntry]]; };
ENDCASE => PupDefs.ReturnFreePupBuffer[b]; };
ENDLOOP;
PupDefs.PupSocketDestroy[serverSoc];
serverSoc _ NIL; };

StartProc: Buttons.ButtonProc = {
data: ClientData _ NARROW[clientData];
overlap: NAT;
SELECT TRUE FROM
shift AND control => overlap _ 5;
control => overlap _ 2;
shift => overlap _ 1;
ENDCASE => overlap _ 0;
Start[data, overlap]; };

Start: PROC [data: ClientData, overlap: NAT] = {
target: ROPE = ViewerTools.GetContents[data.target];
IF data.user # NIL THEN Stop[data];
Report[data, "\nEchoing to ", target];
IF ~FindPath[data, target] THEN RETURN;
IF overlap # 0 THEN IO.PutF[data.log, "%g packets will be kept in flight.\n", [integer[overlap+1]]];
data.pleaseStop _ FALSE;
data.user _ FORK User[data, overlap]; };

HistProc: Buttons.ButtonProc = {
data: ClientData _ NARROW[clientData];
Stop[data];
PrintDelayHist[data]; };

StopProc: Buttons.ButtonProc = {
data: ClientData _ NARROW[clientData];
Stop[data]; };

Stop: PROC [data: ClientData] = TRUSTED {
data.pleaseStop _ TRUE;
IF data.user # NIL THEN JOIN data.user;
data.user _ NIL; };

RouteProc: Buttons.ButtonProc = {
data: ClientData _ NARROW[clientData];
Route[data]; };

Route: PROC [data: ClientData] = TRUSTED {
PrintOne: PROC [rte: PupRouterDefs.RoutingTableEntry] = TRUSTED {
network: DriverDefs.Network _ rte.network;
IF network = NIL THEN RETURN;
nets _ nets + 1;
IF k = 0 THEN IO.PutF[data.log, "|"];
IO.PutF[data.log, "%3B%4B#%3B#%4D |",
[integer[rte.net]],
[integer[network.netNumber.b]],
[integer[IF rte.hop # 0 THEN rte.route ELSE network.hostNumber]],
[integer[rte.hop]] ];
IF (k _ k + 1) = 3 THEN { IO.PutF[data.log, "\n"]; k _ 0; }; };
k, nets: INT _ 0;
IO.PutF[data.log, "\n  Local Pup Routing Table.\n"];
IO.PutF[data.log, "| Net   Via  Hops | Net   Via  Hops | Net   Via  Hops |\n"];
IO.PutF[data.log, "|-----------------|-----------------|-----------------|\n"];
PupRouterDefs.EnumerateRoutingTable[PrintOne];
IF k # 0 THEN IO.PutF[data.log, "\n"];
IF nets > 1 THEN IO.PutF[data.log, "There are %D active networks.\n", [integer[nets]]];
};

StatsProc: Buttons.ButtonProc = {
data: ClientData _ NARROW[clientData];
Stats[data]; };

Stats: PROC [data: ClientData] = TRUSTED {
first: DriverDefs.Network _ DriverDefs.GetDeviceChain[];
FOR network: DriverDefs.Network _ first, network.next UNTIL network = NIL DO
SELECT network.device FROM
ethernet, ethernetOne => {
stats: EthernetDriverStats.EtherStats _ LOOPHOLE[network.stats];
IO.PutF[data.log, "Ethernet"];
IF network.device = ethernetOne THEN IO.PutF[data.log, "One"];
IO.PutF[data.log, " Statistics from %B#%B#.\n",
[integer[network.netNumber.b]], [integer[network.hostNumber]] ];
IO.PutF[data.log, " Rcv: pkts %G, words %G, bad %G, missed %G\n",
[integer[stats.packetsRecv]],
[integer[stats.wordsRecv]],
[integer[stats.badRecvStatus]],
[integer[stats.inputOff]]];
IO.PutF[data.log, " Xmit: pkts %G, words %G, bad %G\n",
[integer[stats.packetsSent]],
[integer[stats.wordsSent]],
[integer[stats.badSendStatus]]];
IO.PutF[data.log, " Lds:"];
FOR i: NAT IN [0..EthernetDriverStats.MaxTries] DO
IO.PutF[data.log, " %G", [integer[stats.loadTable[i]]]];
ENDLOOP;
IO.PutF[data.log, "\n"]; };
ENDCASE => NULL;
ENDLOOP;
};

User: PROC [data: ClientData, overlap: NAT] = TRUSTED {
ENABLE UNWIND => NULL;
start, finish: BasicTime.GMT;
sent, mashed, missed, late, error, funny: INT _ 0;
bytes: INT _ 0;
sendPacketNumber, recvPacketNumber: INTEGER _ 0;
dataChecking: BOOL = data.dataChecking^;
fixedLength: BOOL = data.fixedLength^;
lengthText: ROPE = ViewerTools.GetContents[data.length];
lengthCard: CARDINAL _ 0;
mySoc: PupDefs.PupSocket _ PupDefs.PupSocketMake[
PupTypes.fillInSocketID, data.where, PupDefs.MsToTocks[3000]];
sizeOfStartArray: NAT = 25;
packetStart: ARRAY [0..sizeOfStartArray) OF BasicTime.Pulses;
cond: CONDITION;
grabber: PROCESS;
longest: CARDINAL = PupTypes.maxDataBytesPerGatewayPup;
Kick: ENTRY PROC = TRUSTED {NOTIFY cond; };
Wait: ENTRY PROC = TRUSTED {WAIT cond; };
Grabber: PROC = TRUSTED {
DO
b: PupDefs.PupBuffer _ mySoc.get[];
start, packetStop: BasicTime.Pulses;
recvStartIndex: NAT;
length, pupLength: CARDINAL;
arrivedPacketNumber: INTEGER;
IF b = NIL THEN {
IF data.pleaseStop THEN EXIT; -- Wait for last packet to keep stats clean
missed _ missed + 1;
IF data.miss^ THEN IO.PutRope[data.log, "?"];
recvPacketNumber _ recvPacketNumber + 1;
Kick[];
LOOP; };
IF b.pupType = error THEN {
error _ error + 1;
PrintErrorPup[data, b];
PupDefs.ReturnFreePupBuffer[b];
Kick[];
LOOP;};
IF b.pupType # iAmEcho THEN {
funny _ funny + 1;
IO.PutRope[data.log, "%"];
PupDefs.ReturnFreePupBuffer[b];
Kick[];
LOOP;};
arrivedPacketNumber _ LOOPHOLE[b.pupID.a];
IF (recvPacketNumber-arrivedPacketNumber) > 0 THEN  {
late _ late + 1;
IF data.late^ THEN IO.PutRope[data.log, "#"];
PupDefs.ReturnFreePupBuffer[b];
Kick[];
LOOP; };
UNTIL arrivedPacketNumber = recvPacketNumber DO
missed _ missed + 1;
IF data.miss^ THEN IO.PutRope[data.log, "?"];
recvPacketNumber _ recvPacketNumber + 1;
ENDLOOP;
length _ IF fixedLength THEN lengthCard ELSE recvPacketNumber MOD longest;
pupLength _ PupDefs.GetPupContentsBytes[b];
IF pupLength # length THEN {
funny _ funny + 1;
IO.PutRope[data.log, "%"];
PupDefs.ReturnFreePupBuffer[b];
Kick[];
LOOP; };
packetStop _ BasicTime.GetClockPulses[];
recvStartIndex _ LOOPHOLE[recvPacketNumber, CARDINAL] MOD sizeOfStartArray;
start _ packetStart[recvStartIndex];
AddToDelayHist[data, BasicTime.PulsesToMicroseconds[packetStop-start]];
FOR k: CARDINAL IN [0..length) WHILE dataChecking DO
IF b.pupBytes[k] # k MOD 100H THEN {
IO.PutRope[data.log, "~"];
mashed _ mashed + 1;
EXIT; };
REPEAT FINISHED => {
data.good _ data.good + 1;
bytes _ bytes + length;
recvPacketNumber _ recvPacketNumber + 1;
IF data.echo^ THEN IO.PutRope[data.log, "!"];
IF recvPacketNumber MOD 256 = 0 THEN {
IF ~data.echo^ THEN IO.PutRope[data.log, "."] ELSE IO.PutRope[data.log, "\n"]; }; };
ENDLOOP;
PupDefs.ReturnFreePupBuffer[b];
Kick[];
IF data.pleaseStop AND recvPacketNumber = sendPacketNumber THEN EXIT;
ENDLOOP;
Kick[];
};
IF fixedLength THEN {
temp: INT;
temp _ Convert.IntFromRope[lengthText ! Convert.Error => {
IO.PutF[data.log, "Can't parse Length field.\n"];
lengthCard _ 0;
CONTINUE; } ];
temp _ MAX[temp, 0];
temp _ MIN[temp, longest];
lengthCard _ temp;
IO.PutF[data.log, "Packet length is %G bytes.\n", [integer[lengthCard]]]; };
InitDelayHist[data];
data.good _ 0;
grabber _ FORK Grabber[];
start _ BasicTime.Now[];
UNTIL data.pleaseStop DO
b: PupDefs.PupBuffer _ PupDefs.GetFreePupBuffer[];
length: CARDINAL _ IF fixedLength THEN lengthCard ELSE sendPacketNumber MOD longest;
sendStartIndex: NAT;
b.pupID.a _ b.pupID.b _ LOOPHOLE[sendPacketNumber];
b.pupType _ echoMe;
FOR k: CARDINAL IN [0..length) DO b.pupBytes[k] _ k MOD 100H; ENDLOOP;
PupDefs.SetPupContentsBytes[b, length];
sendStartIndex _ LOOPHOLE[sendPacketNumber, CARDINAL] MOD sizeOfStartArray;
packetStart[sendStartIndex] _ BasicTime.GetClockPulses[];
mySoc.put[b];
sent _ sent + 1;
sendPacketNumber _ sendPacketNumber + 1;
WHILE (sendPacketNumber-recvPacketNumber-overlap) > 0 DO
IF data.pleaseStop THEN EXIT;
Wait[];
ENDLOOP;
ENDLOOP;
IO.PutRope[data.log, "\n"];
finish _ BasicTime.Now[];
JOIN grabber;
PupDefs.PupSocketDestroy[mySoc];
BEGIN
packetsPerSecond, msPerPacket: REAL;
seconds: LONG CARDINAL _ BasicTime.Period[from: start, to: finish];
IF seconds = 0 THEN seconds _ 1;
packetsPerSecond _ REAL[sent]/REAL[seconds];
IF data.good = 0 THEN msPerPacket _ 0
ELSE msPerPacket _ 1000.0*seconds/data.good;
IO.PutF[data.log, "%G packets sent in %G seconds =>\n\t", [integer[sent]], [cardinal[seconds]]];
IO.PutF[data.log, "%1.2F packets/second.\n", [real[packetsPerSecond]] ];
IO.PutF[data.log, "%G bytes received in %G seconds =>\n\t", [integer[bytes]], [cardinal[seconds]]];
IO.PutF[data.log, "%1.0F bits/second => ", [real[8.0*bytes/seconds]] ];
IO.PutF[data.log, "%G ms/packet.\n", [real[msPerPacket]] ];
PrintPercent[data, data.good, sent, "Packets echoed OK"];
PrintPercent[data, mashed, sent, "Packets with bad data"];
PrintPercent[data, missed, sent, "Packets missed"];
PrintPercent[data, late, sent, "Late Packets"];
PrintPercent[data, error, sent, "Error Packets"];
PrintPercent[data, funny, sent, "Funny Packets"];
IO.Flush[data.log];
END; };

InitDelayHist: PROC [data: ClientData] = {
data.minDelay _ INT.LAST;
data.maxDelay _ INT.FIRST;
data.delayHist _ ALL[0]; };

AddToDelayHist: PROC [data: ClientData, micro: INT] = {
FOR d: DelayRange IN DelayRange DO  -- Slow but clean
IF delayTime[d] < micro THEN LOOP;
data.delayHist[d] _ data.delayHist[d] + 1;
EXIT;
REPEAT FINISHED => ERROR;
ENDLOOP;
data.minDelay _ MIN[data.minDelay, micro];
data.maxDelay _ MAX[data.maxDelay, micro]; };

PrintDelayHist: PROC [data: ClientData] = {
total: INT _ 0;
IF data.good = 0 THEN RETURN;
IO.PutF[data.log, "    Incremental      Cumulative    Microseconds\n"];
FOR d: DelayRange IN DelayRange DO
IF data.delayHist[d] = 0 THEN LOOP;
total _ total + data.delayHist[d];
IO.PutF[data.log, "%8G", [integer[data.delayHist[d]]]];
IO.PutF[data.log, "%7.2F%%", [real[100.0*data.delayHist[d]/data.good]]];
IO.PutF[data.log, "%8G", [integer[total]]];
IO.PutF[data.log, "%7.2F%%", [real[100.0*total/data.good]]];
IO.PutF[data.log, "%9G\n", [integer[delayTime[d]]]];
ENDLOOP;
IO.PutF[data.log, "The min delay was %G microseconds.\n", [integer[data.minDelay]]];
IO.PutF[data.log, "The max delay was %G microseconds.\n", [integer[data.maxDelay]]]; };

PokeProc: Buttons.ButtonProc = {
data: ClientData _ NARROW[clientData];
target: ROPE = ViewerTools.GetContents[data.target];
Poke[data, target]; };

Poke: PROC [data: ClientData, target: ROPE] = TRUSTED {
b: PupDefs.PupBuffer;
mySoc: PupDefs.PupSocket;
Report[data, "\nPoking to ", target];
IF ~FindPath[data, target] THEN RETURN;
mySoc _ PupDefs.PupSocketMake[
PupTypes.fillInSocketID, data.where, PupDefs.MsToTocks[5000]];
b _ PupDefs.GetFreePupBuffer[];
b.pupID.a _ b.pupID.b _ 0;
b.pupType _ echoMe;
PupDefs.SetPupContentsBytes[b, 0];
mySoc.put[b];
UNTIL (b _ mySoc.get[]) = NIL DO
SELECT TRUE FROM
(b.pupType = error) => PrintErrorPup[data, b];
(b.pupType # iAmEcho) => IO.PutRope[data.log, "%"];
(b.pupID.a # 0) OR (b.pupID.b # 0) => IO.PutRope[data.log, "#"];
ENDCASE => {
IO.PutRope[data.log, "Response from: "];
IO.PutRope[data.log, PupDefs.GetHostName[b.source]];
IO.PutRope[data.log, " = "];
IO.PutRope[data.log, PupDefs.PupAddressToRope[b.source]];
IO.PutRope[data.log, "\n"]; };
PupDefs.ReturnFreePupBuffer[b];
ENDLOOP;
PupDefs.PupSocketDestroy[mySoc]; };

PrintPercent: PROC [data: ClientData, x, sent: INT, name: ROPE] = {
IF x = 0 THEN RETURN;
IO.PutF[data.log, "%8G %7.2F%%  %G\n", [integer[x]], [real[100.0*x/sent]], [rope[name]] ]; };

PrintErrorPup: PROC [data: ClientData, b: PupDefs.PupBuffer] = TRUSTED {
length: CARDINAL _ PupDefs.GetPupContentsBytes[b];
IO.PutRope[data.log, "Error Pup from: "];
IO.PutRope[data.log, PupDefs.PupAddressToRope[b.source]];
IO.PutRope[data.log, ": "];
FOR i:CARDINAL IN [0..length - 2*(10 + 1 + 1)) DO
IO.PutChar[data.log, b.errorText[i]];
ENDLOOP;
IO.PutRope[data.log, "\n"]; };

FindPath: PROC [data: ClientData, target: ROPE] RETURNS [BOOLEAN] = TRUSTED {
data.where _ PupDefs.GetPupAddress[PupTypes.echoSoc, target !
PupDefs.PupNameTrouble =>
BEGIN Report[data, " Oops: ", e, ".\n"]; GOTO Trouble; END];
Report[data, " = ", PupDefs.PupAddressToRope[data.where], ".\n"];
RETURN[TRUE];
EXITS Trouble => RETURN[FALSE]; };

Report: PROC [data: ClientData, r1,r2,r3,r4: ROPE _ NIL] = TRUSTED {
IF r1 # NIL THEN {IO.PutRope[data.log, r1]};
IF r2 # NIL THEN {IO.PutRope[data.log, r2]};
IF r3 # NIL THEN {IO.PutRope[data.log, r3]};
IF r4 # NIL THEN {IO.PutRope[data.log, r4]}; };

MakeRule: PROC [parent, sibling: Viewer] RETURNS [child: Viewer] = {
child _ Rules.Create[
info: [parent: parent, border: FALSE,
wy: IF sibling = NIL THEN 0 ELSE sibling.wy + sibling.wh + 2, wx: 0, ww: parent.ww, wh: 1],
paint: FALSE ];
Containers.ChildXBound[parent, child]; };

MakeButton: PROC [parent, sibling: Viewer, data: REF ANY, name: ROPE, proc: Buttons.ButtonProc] RETURNS[child: Viewer] = {
child _ Buttons.Create[
info: [name: name, parent: parent, border: TRUE,
wy: sibling.wy, wx: sibling.wx + buttonWidth - 1, ww: buttonWidth],
proc: proc,
clientData: data,
fork: TRUE,
paint: FALSE]; };

SelectorProc: TYPE = PROC [parent: Viewer, clientData: REF, value: ATOM];
Selector: TYPE = REF SelectorRec;
SelectorRec: TYPE = RECORD [
value: REF ATOM,
change: PROC [parent: Viewer, clientData: REF, value: ATOM],
clientData: REF,
buttons: LIST OF Buttons.Button,
values: LIST OF ATOM ];

MakeSelector: PROC
[name: ROPE, values: LIST OF ATOM, init: REF ATOM _ NIL, change: SelectorProc _ NIL, clientData: REF _ NIL, parent: Viewer, x, y: INTEGER]
RETURNS [child: Viewer] = {
selector: Selector _ NEW [SelectorRec _ [
value: IF init # NIL THEN init ELSE NEW [ATOM _ values.first],
change: change,
clientData: clientData,
buttons: NIL,
values: values ] ];
last: LIST OF Buttons.Button _ NIL;
child _ Labels.Create[info: [name: name, parent: parent, border: FALSE, wx: x, wy: y] ];
FOR a: LIST OF ATOM _ values, a.rest UNTIL a = NIL DO
child _ Buttons.Create[
info: [name: Atom.GetPName[a.first], parent: parent, border: TRUE, wx: child.wx + child.ww + 2, wy: child.wy],
proc: SelectorHelper, clientData: selector, fork: TRUE, paint: TRUE];
IF last = NIL THEN last _ selector.buttons _ CONS[first: child, rest: NIL]
ELSE { last.rest _ CONS[first: child, rest: NIL]; last _ last.rest };
IF a.first = selector.value^ THEN Buttons.SetDisplayStyle[child, $WhiteOnBlack];
ENDLOOP; };

SelectorHelper: Buttons.ButtonProc = {
self: Buttons.Button = NARROW[parent];
selector: Selector = NARROW[clientData];
buttons: LIST OF Buttons.Button _ selector.buttons;
FOR a: LIST OF ATOM _ selector.values, a.rest UNTIL a = NIL DO
IF self = buttons.first THEN {
selector.value^ _ a.first;
IF selector.change # NIL THEN selector.change[self.parent, selector.clientData, a.first];
Buttons.SetDisplayStyle[buttons.first, $WhiteOnBlack]; }
ELSE Buttons.SetDisplayStyle[buttons.first, $BlackOnWhite];
buttons _ buttons.rest;
ENDLOOP; };

BoolProc: TYPE = PROC [parent: Viewer, clientData: REF, value: BOOL];
Bool: TYPE = REF BoolRec;
BoolRec: TYPE = RECORD [
value: REF BOOL,
change: BoolProc,
clientData: REF,
button: Viewer ];

MakeBool: PROC
[name: ROPE, init: REF BOOL, change: BoolProc _ NIL, clientData: REF _ NIL, parent: Viewer, x, y: INTEGER]
RETURNS [child: Viewer] = {
bool: Bool _ NEW [BoolRec _ [
value: IF init # NIL THEN init ELSE NEW [BOOL _ TRUE],
change: change,
clientData: clientData,
button: NIL ] ];
child _ Buttons.Create[
info: [name: name, parent: parent, border: TRUE, wx: x, wy: y],
proc: BoolHelper, clientData: bool, fork: TRUE, paint: TRUE];
bool.button _ child;
IF bool.value^ THEN Buttons.SetDisplayStyle[child, $WhiteOnBlack]; };

BoolHelper: Buttons.ButtonProc = {
self: Buttons.Button = NARROW[parent];
bool: Bool = NARROW[clientData];
bool.value^ _ ~bool.value^;
IF bool.value^ THEN Buttons.SetDisplayStyle[bool.button, $WhiteOnBlack]
ELSE Buttons.SetDisplayStyle[bool.button, $BlackOnWhite];
IF bool.change # NIL THEN bool.change[self.parent, bool.clientData, bool.value^]; };

MakeLabel: PROC [parent, sibling: Viewer, name: ROPE] RETURNS [child: Viewer] = {
child _ Labels.Create[
info: [name: name, parent: parent, border: FALSE,
wy: sibling.wy + sibling.wh + (IF sibling.class.flavor = $Button THEN -1 ELSE 2),
wx: 2],
paint: FALSE ]; };

MakeLabeledText: PROC [
parent, sibling: Viewer, name, data: ROPE, prev: Viewer, newline: BOOL _ TRUE] RETURNS [child: Viewer] = {
x: INTEGER = IF newline THEN 2 ELSE sibling.wx + sibling.ww + 10;
y: INTEGER = IF newline THEN sibling.wy + sibling.wh + 1 ELSE sibling.wy;
child _ ViewerTools.MakeNewTextViewer[
info: [parent: parent, wh: buttonHeight, ww: 999, scrollable: TRUE,
data: IF prev = NIL THEN data ELSE ViewerTools.GetContents[prev],
border: FALSE,
wx: x + buttonWidth + 2, wy: y],
paint: FALSE ];
Containers.ChildXBound[parent, child];
[] _ Buttons.Create[
info: [name: name, parent: parent, wh: buttonHeight, border: FALSE, wx: x, wy: y],
proc: LabeledTextProc, clientData: child, fork: FALSE, paint: FALSE];
RETURN[child]; };

LabeledTextProc: Buttons.ButtonProc = {
text: Viewer = NARROW[clientData];
SELECT mouseButton FROM
red => ViewerTools.SetSelection[text, NIL];
yellow => NULL;
blue => { ViewerTools.SetContents[text, NIL]; ViewerTools.SetSelection[text, NIL] };
ENDCASE => ERROR; };

Commander.Register["EchoTool", Create, "Echo Pups to another machine."];

END.



βEchoTool.mesa
Hal Murray December 30, 1985 5:47:23 pm PST
Hal Murray, January 13, 1986 7:10:54 pm PST
Viewer layout parameters
Server data (global)
Note: This server goes in on top of the builtin one
[viewer: ViewerClasses.Viewer, event: ViewerEvent, before: BOOL]
RETURNS[abort: BOOL _ FALSE]
parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL
parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL
parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL
parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL
parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL
parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL
parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL
parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL
parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL
Κ[˜š
œ
™
Icode™+K™+—J˜š
Οk	˜	Jšœœ˜Jšœ
œœ-˜QJšœœ8˜EJšœ
œ˜(Jšœœ$˜4Jšœœ#˜0Jšœ
œ!œ	˜8Jšœœ
˜Jšœœ˜Jšœœ°˜½Jšœ	œH˜VJšœœœ˜Jšœœ
˜Jšœœ˜'Jšœœ
˜Jšœ
œ ˜2Jšœ	œ˜%Jšœ
œX˜gJšœœ=˜NJ˜Jšœœ˜+Jšœœ˜1JšœœA˜XJšœœ,˜?šœœ˜+J˜——šœ
œ
˜š
˜Jšœ:œ]˜™
Jš
œ*˜*—Jš
˜J˜Jšœœœ
˜Jšœœœ
œ
˜Jšœœ˜%™Jšœœ˜Jšœ
œ˜—J˜J™™3Jšœœ˜Jšœœœ
˜Jšœœœ
˜"Jšœœœ
˜Jšœœ
˜*Jšœœ
˜#—J˜Jšœœœ˜%šœœœ˜Jšœœœ
˜Jšœœœ
˜Jšœœœ
˜Jšœœœ
˜Jš
œ6˜6Jšœœœ
˜#Jšœœœ
˜#Jšœœœ
˜#Jšœœœ
˜+Jšœ
œœ
˜+Jšœ'˜+Jšœœ˜Jšœœ˜Jš	œœœ
œœ˜.—J˜šœœ˜Jš
œQ˜QJš
œA˜AJš
œP˜P—J˜šœœœ
œ˜&Jš
œ)˜)Jš
œ)˜)Jš
œ)˜)Jš
œ)˜)Jš
œ˜Jš
œG˜GJš
œS˜SJš
œ_˜_JšœNœ
œ˜Y—J˜JšœœΟc˜'šΟbœœ˜)Jšœœ
˜#Jšœœ˜+J˜š
œ!˜!J˜Jšœ0œœ˜K—Jšœ;œ˜AJš
œ*˜*šœž˜˜&šœ0œ
˜6J˜—Jš	œœœœ	œ˜7—J˜J˜Jš
œ˜—š
œ˜Jšœ9œœ˜H—š
œ4˜4JšœNœ˜U—Jšœ
œ
œ*˜AJš
œ$˜$Jš
œ$˜$Jš
œ!˜!Jš
œ ˜ JšœJ˜LJš
œ˜J˜—šΟn
œœ
œ+˜DJšœœ
˜š
œ!˜!Jšœœœ'˜^—J˜%Jš
œY˜YJš
œw˜wJš
œw˜wJš
œx˜xJš
œ‚
˜‚
Jš
œˆ
˜ˆ
š
œ&˜&J˜
J˜J˜Jš
œ>˜>Jš
œ˜Jšœ	œ˜—Jš
œ˜š
œ&˜&J˜
J˜J˜J˜Jš
œ˜—J˜J˜(Jš
œ8˜8Jš
œ:˜:Jš
œ8˜8Jš
œ8˜8Jš
œ:˜:Jš
œ:˜:J˜š
œ
˜
Jšœœ˜Jšœœ˜)Kšœnœ˜uJ˜CJšœœ(˜>Jš
œR˜R—J˜—šŸœ˜ Jšœ;œ
™@Jšœœœ
™Jšœœ(˜AJš
œœ
œ
œ
œ
˜/Jš
œ˜Jšœœ˜-J˜—š œ
œ˜Jšœ
œ
œ
œ
˜Jšœœ
˜Jšœ	œ
˜J˜—š 
œ
œ	˜"Jšœ
œ
œ
œ
˜Jšœœ
˜Jšœ
œ
œ$œ˜GJšœ	œ˜J˜—š œœ	˜š
œ"˜"Jš
œC˜C—šœ˜Jš
œ'˜'šœœ
˜šœ˜˜J˜J˜ J˜Jšœœ
˜Jšœ
œ
œ˜1—˜'Jšœœ$˜8Jš	œœ
œ
œœ˜<˜Jš
œ'˜'J˜<—˜Jšœ'œ˜@——Jšœ&˜-——Jšœ
˜—Jš
œ$˜$Jšœœ˜J˜—šŸ	œ˜!Jš
œL™LJšœœ
˜&Jšœ	œ
˜
šœ
œ
˜Jšœœ˜!Jš
œ˜Jš
œ˜Jšœ˜—Jš
œ˜J˜—š œœœ˜0Jšœœ(˜4Jšœ
œ
œ˜#Jš
œ&˜&Jšœœ
œ
˜'Jšœ
œ
œN˜dJšœœ
˜Jšœœ˜(J˜—šŸœ˜ Jš
œL™LJšœœ
˜&Jš
œ˜Jš
œ˜J˜—šŸœ˜ Jš
œL™LJšœœ
˜&Jš
œ˜J˜—š œœ	˜)Jšœœ
˜Jšœ
œ
œ
œ˜'Jšœœ˜J˜—šŸ	œ˜!Jš
œL™LJšœœ
˜&Jš
œ˜J˜—š œœ	˜*š œœ*œ˜AJš
œ*˜*Jšœœ
œ
œ
˜Jš
œ˜Jšœœ
œ˜%Jšœaœ
œœ,˜±
Jšœœœ#˜?—Jšœ	œ˜Jšœ2˜4JšœM˜OJšœM˜OJš
œ.˜.Jšœœ
œ˜&Jšœ
œD˜WJš
œ˜—J˜šŸ	œ˜!Jš
œL™LJšœœ
˜&Jš
œ˜J˜—š œœ	˜*Jš
œ8˜8šœ3œœ
˜Lšœ˜š
œ˜Jšœ(œ˜@Jšœ˜Jšœœœ˜>Jšœn˜pJšœ΅
˜·
Jšœ
˜’
Jšœ˜šœœ
œ#˜2Jšœ6˜8Jšœ
˜—Jšœ˜—Jšœœ
˜—Jšœ
˜—Jš
œ˜J˜—š œœœœ˜7Jšœ
œœ
˜Jšœœ
˜Jšœ*œ˜2Jšœœ˜Jšœ$œ˜0Jšœœ˜(Jšœ
œ˜&Jšœœ(˜8Jšœœ˜Jš
œp˜pJšœœ˜Jšœ
œœ˜=Jšœ	œ
˜Jšœ	œ
˜Jšœ	œ&˜7Jš
 œœ
œœœ	˜+Jš
 œœ
œœœ	˜)š œœœ˜š
˜Jš
œ#˜#Jš
œ$˜$Jšœœ
˜Jšœœ
˜Jšœœ
˜šœœ
œ

˜Jšœœ
œž+˜IJš
œ˜Jšœœ
œ˜-Jšœœ
˜(J˜Jšœ˜—šœœ˜Jš
œ˜Jš
œ˜J˜Jš
œ˜Jšœ˜—šœœ˜Jš
œ˜Jšœ˜J˜Jš
œ˜Jšœ˜—Jšœœ˜*šœ,œ˜5Jš
œ˜Jšœœ
œ˜-J˜Jš
œ˜Jšœ˜—šœ(˜/Jš
œ˜Jšœœ
œ˜-Jšœœ
˜(Jšœ
˜—Jš	œ	œ
œœœ	˜JJš
œ+˜+šœœ˜Jš
œ˜Jšœ˜J˜Jš
œ˜Jšœ˜—Jš
œ(˜(Jšœœœœ˜KJš
œ$˜$Jš
œG˜Gš	œœ
œ
œ˜4šœœœ˜$Jšœ˜Jš
œ˜Jšœ˜—š
˜Jš
œ˜Jš
œ˜Jšœœ
˜(Jšœœ
œ˜-šœœ	œ˜&Jš
œ
œ
œœ
œ˜T——Jšœ
˜—J˜J˜Jšœœ%œ
œ
˜EJšœ
˜—J˜Jš
œ˜—šœ
œ˜Jšœœ
˜
š
œ:˜:Jšœ/˜1Jš
œ˜Jšœ˜—Jšœœ
˜Jšœœ˜Jš
œ˜JšœJ˜L—J˜J˜Jšœ
œ˜J˜šœ˜J˜2Jšœœœ
œœœ	˜TJšœœ
˜Jšœœ˜3J˜Jšœœ
œ
œœœ
˜FJš
œ'˜'Jšœœœœ˜KJš
œ9˜9J˜
J˜Jš
œ(˜(šœ1˜8Jšœœ
œ
˜Jš
œ˜Jšœ
˜—Jšœ
˜—Jšœ˜Jš
œ˜Jšœ	˜
J˜ Jš
˜Jšœœ
˜$Jšœ	œ
œ-˜CJšœ
œ
˜ Jšœœœ
˜,Jšœœ˜%Jšœ(˜,Jšœ^˜`JšœF˜HJšœa˜cJšœE˜GJšœ9˜;Jš
œ9˜9J˜:J˜3J˜/J˜1J˜1Jšœ˜Jšœ˜J˜—š 
œœ˜*Jšœœ
œ
˜Jšœœ
œ
˜Jšœœ˜J˜—š œœœ˜7šœœœž˜5Jšœœ
œ
˜"Jš
œ*˜*Jšœ
˜Jšœ
œœ
˜Jšœ
˜Jšœœ˜*Jšœœ˜-J˜——š œœ˜+Jšœœ˜Jšœœ
œ
˜JšœE˜Gšœœ˜"Jšœœ
œ
˜#Jš
œ"˜"Jšœ5˜7JšœF˜HJšœ)˜+Jšœ:˜<Jšœ2˜4Jšœ
˜—JšœR˜TJšœV˜X—šŸœ˜ Jš
œL™LJšœœ
˜&Jšœœ(˜4Jš
œ˜J˜—š œœœœ˜7J˜Jš
œ˜Jš
œ%˜%Jšœœ
œ
˜'š
œ]˜]J˜J˜J˜J˜"J˜
šœœ
˜ šœ
œ
˜Jš
œ.˜.Jšœœ˜3Jšœœœ˜@šœ˜Jšœ&˜(Jšœ2˜4Jšœ˜Jšœ7˜9Jšœ˜——J˜Jšœ
˜——Jš
œ#˜#J˜—š œœœœ˜CJšœœ
œ
˜Jšœ[˜]—J˜š 
œœ,œ˜HJšœœ"˜2Jšœ'˜)Jšœ7˜9Jšœ˜šœœ
œ˜1Jšœ#˜%Jšœ
˜—Jšœ˜J˜—š œœœœœœ˜M˜=˜Jšœ$œ
œ˜<——Jš
œA˜AJšœ
œ˜
Jšœœ
œ˜"J˜—š
 œœ!œœœ˜DJšœœ
œœ˜,Jšœœ
œœ˜,Jšœœ
œœ˜,Jšœœ
œœ˜/—J˜š œœœ˜D˜šœœ
˜%Jš	œœœ
œœ;˜[—Jšœœ˜—Jš
œ)˜)J˜—š 
œœ!œ
œœœ˜z˜šœ+œ
˜0J˜C—J˜J˜Jšœœ
˜Jšœœ˜—J˜—Jš	œœœœ	œ˜IJšœ
œœ
˜!šœ
œœ
˜Jšœœ
œ
˜Jšœœœ	œ˜<Jšœœ
˜Jšœ	œ
œ˜ Jšœœ
œ
œ˜—J˜š œ˜Kšœœ
œ
œ
œœœœœœœ
˜Š
Kšœ˜šœœ˜)Jš
œœœ
œœ
œ
œ˜>J˜J˜Jšœ	œ
˜
J˜—Jšœœ
œœ
˜#JšœAœ˜Xšœœ
œ
œœ˜5š
œ˜Kšœ=œ-˜nJšœ2œ	œ˜E—Jšœœœœ
˜JJšœœœ˜EJšœœ/˜PJšœ˜——J˜šŸœ˜&Jš
œL™LJšœœ	˜&Jšœœ
˜(Jšœ	œ
œ#˜3šœœ
œ
œœ˜>šœœ˜J˜Jšœœ
œ<˜YJš
œ8˜8—Jšœ7˜;J˜Jšœ˜——J˜Jš	œ
œœœ	œ˜EJšœœœ	˜šœ	œœ
˜Jšœœ
œ
˜Jš
œ˜Jšœœ
˜Jš
œ˜—J˜š œ˜Kšœœœ
œœœœœ
˜jKšœ˜šœ
œ˜Jšœœœ
œœ
œœœ˜6J˜Jš
œ˜Jšœœ˜—š
œ˜Kšœ+œ˜?Jšœ*œ	œ˜=—Jš
œ˜Jšœ
œ2˜E—J˜šŸ
œ˜"Jš
œL™LJšœœ	˜&Jšœ
œ
˜ Jš
œ˜Jšœ
œ4˜GJšœ5˜9Jšœœ
œ; 
˜U—š 	œœ œ
	œ˜Q˜šœ+œ
˜1Jšœœ œœ˜QJ˜—Jšœœ˜——J˜š œœ˜Jš	œ%œœœ
	œ˜jJš	œœœ	œœ˜AJš	œœœ	œœ˜I˜&šœ>œ
˜CJš	œœœ
œœ˜AJšœœ
˜J˜ —Jšœœ˜—Jš
œ&˜&˜Jšœ=œ˜RJšœ0œ	œ˜E—Jšœ˜J˜—šŸœ˜'Jš
œL™LJšœœ
˜"šœ
˜Jšœ&œ˜+Jšœ
œ
˜Jšœ(œ"œ˜TJšœœ˜——J˜š
œH˜HJ˜—Jšœ
˜J˜J˜J˜——…—_ϊ~7