-- Copyright (C) 1983, 1985 by Xerox Corporation. All rights reserved.
-- EchoUserTool.mesa, HGM, 7-Nov-85 12:05:21
-- Please don't forget to update the herald....
DIRECTORY
Display USING [Bitmap, Invert, replaceFlags, White],
FormSW USING [
ClientItemsProcType, ProcType, AllocateItemDescriptor, newLine, Display,
Enumerated, EnumeratedItem, FindItem, BooleanItem, CommandItem,
LongNumberItem, NumberItem, StringItem],
Heap USING [systemZone],
Inline USING [BITNOT, BITAND, HighHalf, LowHalf],
MsgSW USING [Post],
Process USING [SetPriority],
Put USING [Char, CR, Text, Line, LongDecimal],
String USING [AppendString, AppendChar, AppendNumber],
Time USING [AppendCurrent, Current],
Tool USING [
Create, MakeSWsProc, UnusedLogName, MakeMsgSW, MakeFormSW, MakeFileSW,
AddThisSW],
ToolWindow USING [CreateSubwindow, DisplayProcType, nullBox, TransitionProcType],
UserInput USING [UserAbort],
Window USING [Handle, Box],
Buffer USING [AccessHandle, DestroyPool, GetBuffer, MakePool, ReturnBuffer],
PupDefs USING [
PupPackageMake, PupPackageDestroy,
PupBuffer, PupSocket, PupSocketDestroy, PupSocketMake, MsToTocks,
SetPupContentsWords, GetPupContentsBytes, DataWordsPerPupBuffer,
AppendPupAddress, GetPupAddress, PupNameTrouble],
PupTypes USING [PupAddress, fillInSocketID, echoSoc, maxDataWordsPerGatewayPup];
EchoUserTool: PROGRAM
IMPORTS
Display, FormSW, Heap, Inline, MsgSW, Process, Put,
String, Time, Tool, ToolWindow, UserInput,
Buffer, PupDefs =
BEGIN OPEN PupDefs, PupTypes;
z: UNCOUNTED ZONE = Heap.systemZone;
msg, form, boxes, log: Window.Handle;
defaultWaitTime: CARDINAL = 2000; -- ms
Pattern: TYPE = {
ignore, zeros, ones, alternating, pairs, oneTwentyFive, countBytes,
countWords, constant, longConstant};
patternChoices: ARRAY Pattern OF FormSW.Enumerated ← [
ignore: ["Ignore", Pattern[ignore]], zeros: ["Zeros", Pattern[zeros]],
ones: ["Ones", Pattern[ones]], alternating: ["125252B", Pattern[alternating]],
pairs: ["146314B", Pattern[pairs]],
oneTwentyFive: ["125B", Pattern[oneTwentyFive]],
countBytes: ["CountBytes", Pattern[countBytes]],
countWords: ["CountWords", Pattern[countWords]],
constant: ["Constant", Pattern[constant]],
longConstant: ["DblWdConstant", Pattern[longConstant]]];
-- Be sure to initialize it when it is allocated!!!!
data: LONG POINTER TO Data ← NIL; -- NIL when we are inactive
Data: TYPE = RECORD [
length: CARDINAL ← 266,
fixedLength: BOOLEAN ← FALSE,
where: PupAddress ← [[0], [0], PupTypes.echoSoc],
picks: ARRAY [0..16] OF CARDINAL ← ALL[0],
drops: ARRAY [0..16] OF CARDINAL ← ALL[0],
sent, good, missed, late, bad, horrible, error, words: LONG CARDINAL ← 0,
pleaseStop: BOOLEAN ← FALSE,
alignTheFink: WORD ← NULL,
lowPriority: BOOLEAN ← FALSE,
alignTheFinkAgain: WORD ← NULL,
noBang: BOOLEAN ← FALSE,
alignTheFinkStillAgain: WORD ← NULL,
noLate: BOOLEAN ← FALSE,
alignTheFinkSomeMore: WORD ← NULL,
noLost: BOOLEAN ← FALSE,
alignTheFinkYetAgain: WORD ← NULL,
waitTime: CARDINAL ← defaultWaitTime,
checkit: BOOLEAN ← TRUE,
echoer: PROCESS ← NULL,
indicator: {left, right, off} ← off,
running: BOOLEAN ← FALSE,
constant: LONG CARDINAL ← 0,
pattern: Pattern ← countBytes,
target: LONG STRING ← NULL];
Initialize: PROCEDURE =
BEGIN
herald: STRING = "Pup Echo User of 7-Nov-85 12:04:12"L;
[] ← Tool.Create[
name: herald, makeSWsProc: MakeSWs, clientTransition: ClientTransition];
END;
EchoUserOn: PROCEDURE =
BEGIN
IF data.length > PupDefs.DataWordsPerPupBuffer[] THEN
BEGIN MsgSW.Post[msg, "Length is too long."L]; RETURN; END;
WriteCR[];
WriteCurrentDateAndTime[];
WriteString[" Echoing to "L];
IF ~FindPath[] THEN RETURN;
data.running ← TRUE;
UpdatePicture[];
data.echoer ← FORK DoIt[];
END;
EchoUserOff: PROCEDURE =
BEGIN
IF data = NIL THEN RETURN;
data.pleaseStop ← TRUE;
JOIN data.echoer[];
data.running ← data.pleaseStop ← FALSE;
UpdatePicture[];
END;
UpdatePicture: PROCEDURE =
BEGIN
FormSW.FindItem[form, startIX].flags.invisible ← data.running;
FormSW.FindItem[form, stopIX].flags.invisible ← ~data.running;
FormSW.Display[form];
END;
FindPath: PROCEDURE RETURNS [BOOLEAN] =
BEGIN OPEN data;
WriteString[target];
WriteChar['=];
where ← [[0], [0], PupTypes.echoSoc];
GetPupAddress[
@where, target !
PupNameTrouble =>
BEGIN MsgSW.Post[msg, e]; WriteLine[e]; GOTO Trouble; END];
PrintPupAddress[where];
WriteLine["."L];
RETURN[TRUE];
EXITS Trouble => RETURN[FALSE];
END;
ClearCounters: PROCEDURE =
BEGIN OPEN data;
sent ← good ← missed ← late ← bad ← horrible ← error ← words ← 0;
picks ← ALL[0];
drops ← ALL[0];
END;
AddToHist: PROCEDURE [
hist: LONG POINTER TO ARRAY [0..16] OF CARDINAL, bits: WORD] =
BEGIN OPEN data;
i: CARDINAL;
IF bits = 0 THEN RETURN;
SELECT bits FROM
1 => i ← 15;
2 => i ← 14;
4 => i ← 13;
10B => i ← 12;
20B => i ← 11;
40B => i ← 10;
100B => i ← 9;
200B => i ← 8;
400B => i ← 7;
1000B => i ← 6;
2000B => i ← 5;
4000B => i ← 4;
10000B => i ← 3;
20000B => i ← 2;
40000B => i ← 1;
100000B => i ← 0;
ENDCASE => i ← 16;
hist[i] ← hist[i] + 1;
END;
PrintSummary: PROCEDURE [howLong: LONG CARDINAL] =
BEGIN OPEN data;
WriteCR[];
WriteLongDecimal[sent];
WriteLine[" packets sent."L];
IF howLong # 0 THEN
BEGIN
WriteLongDecimal[sent/howLong];
WriteLine[" packets per second."L];
WriteLongDecimal[16*words/howLong];
WriteLine[" data bits per second."L];
END;
IF sent # 0 THEN
BEGIN
ShowPercent[good, "good packets received."L];
ShowPercent[missed, "packets missed."L];
ShowPercent[late, "late (or??) packets received."L];
ShowPercent[bad, "bad packets received."L];
ShowPercent[horrible, "packets received with more than 10 words wrong."L];
ShowPercent[error, "error packets received."L];
END;
IF bad # 0 THEN
BEGIN
i: CARDINAL;
x: WORD ← 100000B;
WriteCR[];
WriteLine[" Bit Picked Dropped"L];
FOR i IN [0..16] DO
IF picks[i] # 0 OR drops[i] # 0 THEN
BEGIN
IF i = 16 THEN WriteString[" Other"L] ELSE O6[x];
D8[picks[i]];
D8[drops[i]];
WriteCR[];
END;
x ← x/2;
ENDLOOP;
END;
END;
ShowPercent: PROCEDURE [n: LONG CARDINAL, s: LONG STRING] =
BEGIN OPEN data;
IF n = 0 THEN RETURN;
WriteLongDecimal[n];
WriteString[" ("L];
WriteLongDecimal[n*100/sent];
WriteString["%) "L];
WriteLine[s];
END;
DoIt: PROCEDURE =
BEGIN OPEN data;
pool: Buffer.AccessHandle ← Buffer.MakePool[send: 1, receive: 10];
soc: PupSocket ← PupSocketMake[fillInSocketID, where, MsToTocks[waitTime]];
k: CARDINAL;
b: PupBuffer;
cycle, maxLength, myLength: CARDINAL;
packetNumber: CARDINAL ← LAST[CARDINAL];
start, stop: LONG CARDINAL;
maxLength ← MIN[
length, PupDefs.DataWordsPerPupBuffer[], PupTypes.maxDataWordsPerGatewayPup];
IF lowPriority THEN Process.SetPriority[0];
ClearCounters[];
IF fixedLength THEN
BEGIN
WriteString["Packet length is "L];
WriteDecimal[maxLength];
WriteLine[" words."L];
END;
SetupBoxes[];
start ← Time.Current[];
UNTIL pleaseStop OR UserInput.UserAbort[log] DO
-- NB: No check for short buffers
FOR cycle IN [0..256) UNTIL pleaseStop OR UserInput.UserAbort[log] DO
b ← Buffer.GetBuffer[pup, pool, send];
myLength ← IF fixedLength THEN maxLength ELSE MIN[maxLength, cycle];
SELECT pattern FROM
ignore => NULL;
zeros => FOR k IN [0..myLength) DO b.pup.pupWords[k] ← 0; ENDLOOP;
ones => FOR k IN [0..myLength) DO b.pup.pupWords[k] ← 177777B; ENDLOOP;
alternating =>
FOR k IN [0..myLength) DO b.pup.pupWords[k] ← 125252B; ENDLOOP;
pairs => FOR k IN [0..myLength) DO b.pup.pupWords[k] ← 146314B; ENDLOOP;
oneTwentyFive =>
FOR k IN [0..myLength) DO b.pup.pupWords[k] ← 125B; ENDLOOP;
countBytes =>
FOR k IN [0..myLength) DO
b.pup.pupWords[k] ← 2*k*400B + (2*k + 1) MOD 400B; ENDLOOP;
countWords => FOR k IN [0..myLength) DO b.pup.pupWords[k] ← k; ENDLOOP;
constant =>
FOR k IN [0..myLength) DO
b.pup.pupWords[k] ← Inline.LowHalf[data.constant]; ENDLOOP;
longConstant =>
BEGIN
FOR k IN [0..myLength) DO
b.pup.pupWords[k] ←
IF Inline.BITAND[k, 1] = 0 THEN Inline.HighHalf[data.constant]
ELSE Inline.LowHalf[data.constant];
ENDLOOP;
END;
ENDCASE => ERROR;
b.pup.pupID.a ← b.pup.pupID.b ← (packetNumber ← packetNumber + 1);
b.pup.pupType ← echoMe;
SetPupContentsWords[b, myLength];
soc.put[b];
sent ← sent + 1;
words ← words + myLength;
UNTIL (b ← soc.get[]) = NIL DO
-- Until timeout, or we find the expected one
SELECT TRUE FROM
(b.pup.pupType = error) =>
BEGIN error ← error + 1; WriteCR[]; PrintErrorPup[b]; END;
((b.pup.pupType # iAmEcho) OR (b.pup.pupID.a # packetNumber)
OR (b.pup.pupID.b # packetNumber)
OR (GetPupContentsBytes[b] # 2*myLength)) =>
BEGIN late ← late + 1; IF ~noLate THEN WriteChar['#]; END;
ENDCASE =>
BEGIN
hits: CARDINAL ← 0;
FlipBoxes[];
IF data.checkit THEN
FOR k IN [0..myLength) DO
expected: WORD;
SELECT pattern FROM
ignore => EXIT;
zeros => expected ← 0;
ones => expected ← 177777B;
alternating => expected ← 125252B;
pairs => expected ← 146314B;
oneTwentyFive => expected ← 125B;
countBytes => expected ← 2*k*400B + (2*k + 1) MOD 400B;
countWords => expected ← k;
constant => expected ← Inline.LowHalf[data.constant];
longConstant =>
expected ←
IF Inline.BITAND[k, 1] = 0 THEN Inline.HighHalf[
data.constant] ELSE Inline.LowHalf[data.constant];
ENDCASE => ERROR;
IF b.pup.pupWords[k] # expected THEN
BEGIN OPEN Inline;
found, picked, dropped: WORD;
IF hits = 0 THEN
BEGIN
WriteCR[];
WriteCurrentDateAndTime[];
WriteString[" Data compare error(s) on packet number "L];
WriteDecimal[packetNumber];
WriteLine["."L];
WriteLine["Idx Expected Found Picked Dropped"L];
END;
found ← b.pup.pupWords[k];
picked ← BITAND[found, BITNOT[expected]];
dropped ← BITAND[expected, BITNOT[found]];
AddToHist[@picks, picked];
AddToHist[@drops, dropped];
IF hits < 10 THEN
BEGIN
O3[k];
O9[expected];
O9[found];
O9[picked];
O9[dropped];
WriteCR[];
END;
hits ← hits + 1;
END;
ENDLOOP;
IF hits = 0 THEN good ← good + 1 ELSE bad ← bad + 1;
IF hits = 0 AND ~noBang THEN WriteChar['!];
IF hits > 10 THEN
BEGIN horrible ← horrible + 1; WriteLine["...."L]; END;
EXIT; -- found the expected one
END;
Buffer.ReturnBuffer[b];
ENDLOOP;
IF b # NIL THEN Buffer.ReturnBuffer[b]
ELSE BEGIN missed ← missed + 1; IF ~noLost THEN WriteChar['?]; END;
ENDLOOP;
IF ~noBang THEN WriteCR[] ELSE WriteChar['.];
ENDLOOP;
stop ← Time.Current[];
WriteCR[];
PupSocketDestroy[soc];
Buffer.DestroyPool[pool];
SetDownBoxes[];
PrintSummary[stop - start];
IF ~pleaseStop THEN UpdatePicture[];
END;
-- IO things
WriteChar: PROCEDURE [c: CHARACTER] = BEGIN Put.Char[log, c]; END;
WriteCR: PROCEDURE = BEGIN Put.CR[log]; END;
WriteString: PROCEDURE [s: LONG STRING] = BEGIN Put.Text[log, s]; END;
WriteLine: PROCEDURE [s: LONG STRING] = BEGIN Put.Line[log, s]; END;
WriteLongDecimal: PROCEDURE [n: LONG CARDINAL] =
BEGIN Put.LongDecimal[log, n]; END;
WriteDecimal: PROCEDURE [n: CARDINAL] = INLINE BEGIN WriteNumber[n, 10, 0]; END;
WriteOctal: PROCEDURE [n: CARDINAL] = INLINE BEGIN WriteNumber[n, 8, 0]; END;
WriteNumber: PROCEDURE [n, radix, width: CARDINAL] = INLINE
BEGIN
temp: STRING = [25];
String.AppendNumber[temp, n, radix];
THROUGH [temp.length..width) DO WriteChar[' ]; ENDLOOP;
WriteString[temp];
END;
D8: PROCEDURE [n: CARDINAL] = BEGIN WriteNumber[n, 10, 8]; END;
O3: PROCEDURE [n: CARDINAL] = BEGIN WriteNumber[n, 8, 3]; END;
O6: PROCEDURE [n: CARDINAL] = BEGIN WriteNumber[n, 8, 6]; END;
O9: PROCEDURE [n: CARDINAL] = BEGIN WriteNumber[n, 8, 9]; END;
WriteCurrentDateAndTime: PROCEDURE =
BEGIN time: STRING = [20]; Time.AppendCurrent[time]; WriteString[time]; END;
PrintPupAddress: PROCEDURE [a: PupAddress] =
BEGIN temp: STRING = [40]; AppendPupAddress[temp, a]; WriteString[temp]; END;
PrintErrorPup: PUBLIC PROCEDURE [b: PupDefs.PupBuffer] =
BEGIN
i, len: CARDINAL;
temp: STRING = [100];
String.AppendString[temp, "Error Pup, code="L];
String.AppendNumber[temp, b.pup.errorCode, 8];
String.AppendString[temp, ", from: "L];
AppendPupAddress[temp, b.pup.source];
String.AppendString[temp, ": "L];
len ← PupDefs.GetPupContentsBytes[b];
FOR i IN [0..len - 2*(10 + 1 + 1)) UNTIL temp.length = temp.maxlength DO
String.AppendChar[temp, b.pup.errorText[i]]; ENDLOOP;
WriteLine[temp];
MsgSW.Post[msg, temp];
END;
indicatorBox: Window.Box = [[25, 10], [16, 16]];
DisplayBoxes: ToolWindow.DisplayProcType =
BEGIN
pattern: ARRAY [0..1] OF ARRAY [0..8) OF WORD;
left: WORD = 177400B;
right: WORD = 000377B;
SELECT data.indicator FROM
left => pattern ← [ALL[left], ALL[right]];
right => pattern ← [ALL[right], ALL[left]];
off => pattern ← [ALL[0], ALL[0]];
ENDCASE;
Display.Bitmap[window, indicatorBox, [@pattern, 0, 0], 16, Display.replaceFlags]
END;
SetupBoxes: PROCEDURE = BEGIN data.indicator ← left; DisplayBoxes[boxes]; END;
FlipBoxes: PROCEDURE =
BEGIN
SELECT data.indicator FROM
left => data.indicator ← right;
off, right => data.indicator ← left;
ENDCASE;
Display.Invert[boxes, indicatorBox];
END;
SetDownBoxes: PROCEDURE =
BEGIN data.indicator ← off; Display.White[boxes, indicatorBox]; END;
MakeBoxesSW: PROCEDURE [window: Window.Handle] =
BEGIN
box: Window.Box ← ToolWindow.nullBox;
box.dims.h ← 36;
boxes ← ToolWindow.CreateSubwindow[parent: window, display: DisplayBoxes, box: box];
Tool.AddThisSW[window: window, sw: boxes, swType: vanilla];
END;
Start: FormSW.ProcType = BEGIN EchoUserOn[]; END;
Stop: FormSW.ProcType = BEGIN EchoUserOff[]; END;
MakeSWs: Tool.MakeSWsProc =
BEGIN
logFileName: STRING = [40];
msg ← Tool.MakeMsgSW[window: window, lines: 5];
form ← Tool.MakeFormSW[window: window, formProc: MakeForm];
MakeBoxesSW[window];
Tool.UnusedLogName[logFileName, "EchoUser.log$"L];
log ← Tool.MakeFileSW[window: window, name: logFileName, allowTypeIn: FALSE];
END;
startIX: CARDINAL = 0;
stopIX: CARDINAL = 1;
runningIX: CARDINAL = 2;
MakeForm: FormSW.ClientItemsProcType =
BEGIN
nParams: CARDINAL = 13;
items ← FormSW.AllocateItemDescriptor[nParams];
items[0] ← FormSW.CommandItem[
tag: "Start"L, proc: Start, place: FormSW.newLine];
items[1] ← FormSW.CommandItem[
tag: "Stop"L, proc: Stop, place: FormSW.newLine, invisible: TRUE];
items[2] ← FormSW.BooleanItem[tag: "LowPriority"L, switch: @data.lowPriority];
items[3] ← FormSW.NumberItem[
tag: "WaitTime(ms)"L, value: @data.waitTime, default: defaultWaitTime];
items[4] ← FormSW.BooleanItem[
tag: "!-Off"L, switch: @data.noBang, place: FormSW.newLine];
items[5] ← FormSW.BooleanItem[tag: "#-Off"L, switch: @data.noLate];
items[6] ← FormSW.BooleanItem[tag: "?-Off"L, switch: @data.noLost];
items[7] ← FormSW.BooleanItem[tag: "Checkit"L, switch: @data.checkit];
items[8] ← FormSW.EnumeratedItem[
tag: "Pattern"L, value: @data.pattern,
choices: LOOPHOLE[LONG[DESCRIPTOR[patternChoices]]]];
items[9] ← FormSW.LongNumberItem[
tag: "Constant"L, value: @data.constant, default: 0, radix: octal];
items[10] ← FormSW.BooleanItem[
tag: "FixedLength"L, switch: @data.fixedLength, place: FormSW.newLine];
items[11] ← FormSW.NumberItem[tag: "(Max)Length"L, value: @data.length];
items[12] ← FormSW.StringItem[
tag: "Target"L, string: @data.target, place: FormSW.newLine, inHeap: TRUE];
RETURN[items, TRUE];
END;
AlreadyActive: ERROR = CODE;
NotActive: ERROR = CODE;
ClientTransition: ToolWindow.TransitionProcType =
BEGIN
SELECT TRUE FROM
old = inactive =>
BEGIN
IF data # NIL THEN ERROR AlreadyActive;
data ← z.NEW[Data];
data↑ ← [];
data.target ← z.NEW[StringBody[20]];
String.AppendString[data.target, "ME"L];
[] ← PupDefs.PupPackageMake[];
END;
new = inactive =>
BEGIN
IF data = NIL THEN ERROR NotActive;
IF data.running THEN EchoUserOff[];
PupDefs.PupPackageDestroy[];
z.FREE[@data.target];
z.FREE[@data];
END;
ENDCASE;
END;
-- Main Body
Initialize[];
END.