DIRECTORY
Basics USING [BITAND, LowHalf],
Convert USING [CardFromRope, Error],
IO,
LarkControl USING [LarkData],
LarkPrograms USING [FindVariable, PatchFromFile, PatchItem, ProcedureEnclosing, STObject],
LarkWork USING [LarkWorkProc, RegisterLarkWorkProc],
Rope USING [ROPE],
RPCPkt,
TeleLoad USING [CoreAddress, Failed, FlushWrites, Handle, Read, ReadWord, ResetCache, SetCacheSize, WriteWord];

LarkWorkCommandsC: CEDAR PROGRAM
IMPORTS Basics, Convert, IO, LarkPrograms, LarkWork, TeleLoad =
BEGIN
BadCommRope: Rope.ROPE = "Communications Failure\n";
BadArgsRope: Rope.ROPE = "Bad Arguments\n";

ShortCoreAddress: TYPE = CARDINAL;

ECB: TYPE = RECORD [
link: ShortCoreAddress,
kp: ShortCoreAddress,
srcp: ShortCoreAddress,
dstp: ShortCoreAddress,
count: CARDINAL,
encrypt: CARDINAL,  -- BOOL
item: CARDINAL,
proc: ShortCoreAddress
];

Byte: TYPE = [0..377B];

LarkPORT: TYPE = RECORD [
net: Byte,
host: Byte,
a: CARDINAL,
b: CARDINAL
];

Queue: TYPE = RECORD [
head: ShortCoreAddress,
tail: ShortCoreAddress
];

VCB: TYPE = RECORD [
active: CARDINAL,
lport: LarkPORT,
rport: LarkPORT,
numPackets: CARDINAL,
lastEndTime: CARDINAL,
bufbase: ShortCoreAddress,
vpq: Queue,
pq: Queue,
pqlength: CARDINAL,
loECB: ECB,
hiECB: ECB,
floECB: ECB,
fhiECB: ECB,
now: CARDINAL,
silThresh: CARDINAL,
silVal: ShortCoreAddress,
encIndex: CARDINAL,
squelchTail: CARDINAL,
expPlayTime: CARDINAL,
firstPacket: CARDINAL,
daECB: ECB,
dbECB: ECB,
lsoc: CARDINAL,
dtimer: CARDINAL,
gainChannel: CARDINAL,
lastEnergy: CARDINAL,
gainCount: CARDINAL,
decayTime: CARDINAL,
gainLevel: CARDINAL,
gainTable: ARRAY [0..5) OF CARDINAL,
expPktID: CARDINAL
];

PrintECB: PROC [lark: LarkControl.LarkData, out: IO.STREAM, ecb: ECB] = {
out.PutF["ECB[link: %04xH, kp: %04xH, srcp: %04xH, dstp: %04xH, ", IO.card[ecb.link], IO.card[ecb.kp], IO.card[ecb.srcp], IO.card[ecb.dstp]];
out.PutF["count: %d,\n    encrypt: %04xH, item: %04x, proc: %04x", IO.card[ecb.count], IO.card[ecb.encrypt], IO.card[ecb.item], IO.card[ecb.proc]];
out.PutF["(%g)]", IO.rope[LarkPrograms.ProcedureEnclosing[lark.program, ecb.proc].id]];
};

PrintPort: PROC [lark: LarkControl.LarkData, out: IO.STREAM, port: LarkPORT] = {
out.PutF["%b#%b#%b,%b", IO.card[port.net], IO.card[port.host], IO.card[port.a], IO.card[port.b]];
};

PrintQueue: PROC [lark: LarkControl.LarkData, out: IO.STREAM, q: Queue, max: NAT, printTail: BOOL _ TRUE] = {
v, lastv: ShortCoreAddress;
v _ q.head;
out.PutRope["[ "];
FOR i: NAT IN [0..max) DO
lastv _ v;
IF v = 0 THEN EXIT;
out.PutF["%04xH", IO.card[v]];
v _ TeleLoad.ReadWord[lark.h, v];
IF v = 0 THEN EXIT;
out.PutRope[", "];
REPEAT
FINISHED => out.PutRope["..."];
ENDLOOP;
out.PutRope[" ]"];
IF printTail THEN {
IF lastv = q.tail THEN out.PutRope["(ok)"] ELSE out.PutF["(tail: %04xH)", IO.card[q.tail]];
};
};

PrintVCB: PROC [lark: LarkControl.LarkData, out: IO.STREAM, vcb: VCB, vcbIndex: NAT] = {
out.PutF[IF vcb.active # 0 THEN "VCB %d Active\n" ELSE "VCB %d inactive\n", IO.card[vcbIndex]];

out.PutRope["  local: "];
PrintPort[lark: lark, out: out, port: vcb.lport];
out.PutRope[" remote: "];
PrintPort[lark: lark, out: out, port: vcb.rport];
out.PutRope["\n"];

out.PutF["  numPackets: %d, lastEndTime: %04xH, bufbase: %04xH\n", IO.card[vcb.numPackets], IO.card[vcb.lastEndTime], IO.card[vcb.bufbase]];

out.PutRope["  vpq: "];
PrintQueue[lark: lark, out: out, q: vcb.vpq, max: 8];
out.PutRope["\n"];

out.PutRope["  pq: "];
PrintQueue[lark: lark, out: out, q: vcb.pq, max: 8];
out.PutRope["\n"];

out.PutF["  pqlength: %d\n", IO.card[vcb.pqlength]];

out.PutRope["  loECB: "];
PrintECB[lark: lark, out: out, ecb: vcb.loECB];
out.PutRope["\n"];

out.PutRope["  hiECB: "];
PrintECB[lark: lark, out: out, ecb: vcb.hiECB];
out.PutRope["\n"];

out.PutRope["  floECB: "];
PrintECB[lark: lark, out: out, ecb: vcb.floECB];
out.PutRope["\n"];

out.PutRope["  fhiECB: "];
PrintECB[lark: lark, out: out, ecb: vcb.fhiECB];
out.PutRope["\n"];

out.PutF["  now: %04xH, silThresh: %04xH, silVal: %04xH\n", IO.card[vcb.now], IO.card[vcb.silThresh], IO.card[vcb.silVal]];

out.PutF["  encIndex: %d, squelchTail: %d, expPlayTime: %04xH, firstPacket: %04xH\n", IO.card[vcb.encIndex], IO.card[vcb.squelchTail], IO.card[vcb.expPlayTime], IO.card[vcb.firstPacket]];

out.PutRope["  daECB: "];
PrintECB[lark: lark, out: out, ecb: vcb.daECB];
out.PutRope["\n"];

out.PutRope["  dbECB: "];
PrintECB[lark: lark, out: out, ecb: vcb.dbECB];
out.PutRope["\n"];

out.PutF["  lsoc: %04xH, dtimer: %04xH\n", IO.card[vcb.lsoc], IO.card[vcb.dtimer]];
out.PutF["  gainChannel: %d, lastEnergy: %x, gainCount: %d\n", IO.card[vcb.gainChannel], IO.card[vcb.lastEnergy], IO.card[vcb.gainCount]];
out.PutF["  decayTime: %d, gainLevel: %d\n", IO.card[vcb.decayTime], IO.card[vcb.gainLevel]];

out.PutF["  gainTable 0: %4x, 1: %4x, 2: %4x", IO.card[vcb.gainTable[0]], IO.card[vcb.gainTable[1]], IO.card[vcb.gainTable[2]]];
out.PutF[" 3: %4x, 4: %4x\n", IO.card[vcb.gainTable[3]], IO.card[vcb.gainTable[4]]];
out.PutF["  expPktID: %04xH\n", IO.card[vcb.expPktID]];

};

ReadVCB: PROC [h: TeleLoad.Handle, vcbAddr: TeleLoad.CoreAddress] RETURNS [vcb: VCB] = {
offset: NAT _ 0;
Next: PROC RETURNS [v: CARDINAL] = {
v _ TeleLoad.ReadWord[h, vcbAddr + offset];
offset _ offset + 2;
};
ReadECB: PROC RETURNS [ecb: ECB] = {
ecb.link _ Next[];
ecb.kp _ Next[];
ecb.srcp _ Next[];
ecb.dstp _ Next[];
ecb.count _ Next[];
ecb.encrypt _ Next[];
ecb.item _ Next[];
ecb.proc _ Next[];
};
ReadPort: PROC RETURNS [port: LarkPORT] = {
port.net _ TeleLoad.Read[h, vcbAddr + offset];
offset _ offset + 1;
port.host _ TeleLoad.Read[h, vcbAddr + offset];
offset _ offset + 1;
port.a _ Next[];
port.b _ Next[];
};
ReadQueue: PROC RETURNS [q: Queue] = {
q.head _ Next[];
q.tail _ Next[];
};
vcb.active _ Next[];
vcb.lport _ ReadPort[];
vcb.rport _ ReadPort[];
vcb.numPackets _ Next[];
vcb.lastEndTime _ Next[];
vcb.bufbase _ Next[];
vcb.vpq _ ReadQueue[];
vcb.pq _ ReadQueue[];
vcb.pqlength _ Next[];
vcb.loECB _ ReadECB[];
vcb.hiECB _ ReadECB[];
vcb.floECB _ ReadECB[];
vcb.fhiECB _ ReadECB[];
vcb.now _ Next[];
vcb.silThresh _ Next[];
vcb.silVal _ Next[];
vcb.encIndex _ Next[];
vcb.squelchTail _ Next[];
vcb.expPlayTime _ Next[];
vcb.firstPacket _ Next[];
vcb.daECB _ ReadECB[];
vcb.dbECB _ ReadECB[];
vcb.lsoc _ Next[];
vcb.dtimer _ Next[];
vcb.gainChannel _ Next[];
vcb.lastEnergy _ Next[];
vcb.gainCount _ Next[];
vcb.decayTime _ Next[];
vcb.gainLevel _ Next[];
vcb.gainTable[0] _ Next[];
vcb.gainTable[1] _ Next[];
vcb.gainTable[2] _ Next[];
vcb.gainTable[3] _ Next[];
vcb.gainTable[4] _ Next[];
vcb.expPktID _ Next[];
};

DspVCB: LarkWork.LarkWorkProc = {
ENABLE {
Convert.Error => GOTO BadArgs;
TeleLoad.Failed => GOTO BadComm;
};
out: IO.STREAM _ lark.h.log;
vcbAddr: TeleLoad.CoreAddress;
vcbIndex: CARDINAL;
vcbItem: LarkPrograms.STObject;
found: BOOL;
vcb: VCB;
IF argv.argc > 1 THEN {
vcbIndex _ Basics.LowHalf[Convert.CardFromRope[argv[1]]];
IF vcbIndex > 4 THEN GOTO BadArgs;
};
[item: vcbItem, found: found] _ LarkPrograms.FindVariable[lark.program, "vcb"];
IF found THEN vcbAddr _ vcbItem.addr
ELSE RETURN["can't get symbol vcb\n"];
TeleLoad.ResetCache[lark.h];
IF argv.argc > 1 THEN PrintVCB[lark: lark, out: out, vcb: ReadVCB[h: lark.h, vcbAddr: vcbAddr + (2 * vcbIndex * SIZE[VCB])], vcbIndex: vcbIndex]
ELSE FOR vcbIndex IN [0..4] DO
vcb _ ReadVCB[h: lark.h, vcbAddr: vcbAddr + (2 * vcbIndex * SIZE[VCB])];
IF vcb.active # 0 THEN PrintVCB[lark: lark, out: out, vcb: vcb, vcbIndex: vcbIndex];
ENDLOOP;
EXITS
BadArgs => RETURN[BadArgsRope];
BadComm => RETURN[BadCommRope];
};

ESSet: LarkWork.LarkWorkProc = {
ENABLE {
Convert.Error => GOTO BadArgs;
TeleLoad.Failed => GOTO BadComm;
};
pvcb: POINTER TO VCB;
offsetGainChannel: CARDINAL;
offsetLastEnergy: CARDINAL;
offsetDecayTime: CARDINAL;
offsetGainTable: CARDINAL;
vcbAddr: TeleLoad.CoreAddress;
vcbIndex: CARDINAL;
gainControl: CARDINAL;
decayTime: CARDINAL;
gainTable: ARRAY [0..5) OF CARDINAL;
vcbItem: LarkPrograms.STObject;
found: BOOL;
TRUSTED {
pvcb _ LOOPHOLE[0];
offsetGainChannel _ LOOPHOLE[@pvcb.gainChannel, CARDINAL] * 2;
offsetLastEnergy _ LOOPHOLE[@pvcb.lastEnergy, CARDINAL] * 2;
offsetDecayTime _ LOOPHOLE[@pvcb.decayTime, CARDINAL] * 2;
offsetGainTable _ LOOPHOLE[@pvcb.gainTable, CARDINAL] * 2;
};
IF argv.argc # 9 THEN GOTO BadArgs;
[item: vcbItem, found: found] _ LarkPrograms.FindVariable[lark.program, "vcb"];
IF found THEN vcbAddr _ vcbItem.addr
ELSE RETURN["can't get symbol vcb\n"];
vcbIndex _ Basics.LowHalf[Convert.CardFromRope[argv[1]]];
IF vcbIndex > 4 THEN GOTO BadArgs;
gainControl _ Basics.LowHalf[Convert.CardFromRope[argv[2]]];
IF gainControl NOT IN [0..3] THEN GOTO BadArgs;
decayTime _ Basics.LowHalf[Convert.CardFromRope[argv[3]]];
IF decayTime NOT IN [1..31] THEN GOTO BadArgs;
FOR i: NAT IN [0..5) DO
gainTable[i] _ Basics.LowHalf[Convert.CardFromRope[argv[4+i]]];
ENDLOOP;
TeleLoad.ResetCache[lark.h];
TeleLoad.SetCacheSize[lark.h, 2];
vcbAddr _ vcbAddr + (vcbIndex * SIZE[VCB] * 2);
TeleLoad.WriteWord[h: lark.h, addr: vcbAddr + offsetGainChannel, value: gainControl];
TeleLoad.WriteWord[h: lark.h, addr: vcbAddr + offsetLastEnergy, value: 0];
TeleLoad.WriteWord[h: lark.h, addr: vcbAddr + offsetDecayTime, value: decayTime];
FOR i: NAT IN [0..5) DO
TeleLoad.WriteWord[h: lark.h, addr: vcbAddr + offsetGainTable + (i * 2), value: gainTable[i]];
ENDLOOP;
TeleLoad.FlushWrites[lark.h];
TeleLoad.SetCacheSize[lark.h, 0];
EXITS
BadArgs => RETURN[BadArgsRope];
BadComm => RETURN[BadCommRope];
};

DspStatics: LarkWork.LarkWorkProc = {
ENABLE {
Convert.Error => GOTO BadArgs;
TeleLoad.Failed => GOTO BadComm;
};
out: IO.STREAM _ lark.h.log;
pl: LIST OF LarkPrograms.PatchItem;
pll: LIST OF LarkPrograms.PatchItem;
TeleLoad.ResetCache[lark.h];
IF argv.argc # 2 THEN GOTO BadArgs;
pll _ LarkPrograms.PatchFromFile[program: lark.program, fileName: argv[1], log: out];
IF pll = NIL THEN RETURN[NIL];
UNTIL pll = NIL DO  -- reverse the list
pl _ CONS[pll.first, pl];
pll _ pll.rest;
ENDLOOP;
WHILE pl # NIL DO
pl.first.wordValue _ TeleLoad.ReadWord[h: lark.h, addr: pl.first.address];
out.PutF["%-15g: %04xH (%d d)\n", IO.rope[pl.first.name], IO.card[pl.first.wordValue], IO.int[pl.first.wordValue]];
pl _ pl.rest;
ENDLOOP;
EXITS
BadArgs => RETURN[BadArgsRope];
BadComm => RETURN[BadCommRope];
};

ZeroStatics: LarkWork.LarkWorkProc = {
ENABLE {
Convert.Error => GOTO BadArgs;
TeleLoad.Failed => GOTO BadComm;
};
out: IO.STREAM _ lark.h.log;
pl: LIST OF LarkPrograms.PatchItem;
IF argv.argc # 2 THEN GOTO BadArgs;
pl _ LarkPrograms.PatchFromFile[program: lark.program, fileName: argv[1], log: out];
IF pl = NIL THEN RETURN[NIL];
TeleLoad.FlushWrites[lark.h];
TeleLoad.SetCacheSize[lark.h, 2];
WHILE pl # NIL DO
TeleLoad.WriteWord[h: lark.h, addr: pl.first.address, value: 0];
out.PutF["%g "];
pl _ pl.rest;
ENDLOOP;
TeleLoad.FlushWrites[lark.h];
TeleLoad.SetCacheSize[lark.h, 0];
out.PutChar['\n];
EXITS
BadArgs => RETURN[BadArgsRope];
BadComm => RETURN[BadCommRope];
};

DspAnalog: LarkWork.LarkWorkProc = {
ENABLE {
TeleLoad.Failed => GOTO BadComm;
};
out: IO.STREAM _ lark.h.log;
xbarState: ARRAY [0..7] OF CARDINAL;
rowBits: ARRAY [0..7] OF CARDINAL = [1, 2, 4, 8, 16, 32, 64, 128];
sources: ARRAY [0..7] OF Rope.ROPE = ["Codec1", "Teleset", "TeleWall", "Mike", "Silence", "Codec2", "Line1", "Line2"];
sinks: ARRAY [0..7] OF Rope.ROPE = ["Codec1", "Teleset", "TeleWall", "Speaker", "DTMF", "Codec2", "Line1", "Line2"];
xbItem: LarkPrograms.STObject;
pioState: ARRAY [0..5] OF CARDINAL;
pioItem: LarkPrograms.STObject;
inAnItem: LarkPrograms.STObject;
inAn: CARDINAL;
found: BOOL;
ipioa: NAT = 0;
ipiob: NAT = 1;
ipioc: NAT = 2;
iapioa: NAT = 3;
iapiob: NAT = 4;
iapioc: NAT = 5;
AISwitch: NAT = 2;
AIRing: NAT = 4;
AIHookSwitch: NAT = 8;
GetBit: PROC [row, col: NAT] RETURNS [BOOL] = {
RETURN [LOOPHOLE[Basics.BITAND[rowBits[row], xbarState[col]], CARDINAL] # 0];
};
PIOOn: PROC [bit, byte: NAT] RETURNS [BOOL] = {
RETURN [LOOPHOLE[Basics.BITAND[bit, pioState[byte]], CARDINAL] # 0];
};
PIOOff: PROC [bit, byte: NAT] RETURNS [BOOL] = {
RETURN [LOOPHOLE[Basics.BITAND[bit, pioState[byte]], CARDINAL] = 0];
};
TeleLoad.ResetCache[lark.h];
[item: xbItem, found: found] _ LarkPrograms.FindVariable[lark.program, "xBarState"];
IF NOT found THEN RETURN["Can't find symbol xBarState"];
FOR i: NAT IN [0..7] DO
xbarState[i] _ TeleLoad.Read[h: lark.h, addr: xbItem.addr + i];
ENDLOOP;
FOR row: NAT IN [0..7] DO
found _ FALSE;
FOR col: NAT IN [0..7] DO
IF GetBit[row, col] THEN found _ TRUE;
ENDLOOP;
IF NOT found THEN LOOP;
out.PutRope[sources[row]];
FOR col: NAT IN [0..7] DO
IF GetBit[row, col] THEN out.PutF[" -> %g ", IO.rope[sinks[col]]];
ENDLOOP;
out.PutChar['\n];
ENDLOOP;
[item: pioItem, found: found] _ LarkPrograms.FindVariable[lark.program, "vpio"];
IF NOT found THEN RETURN["Can't find symbol vpio"];
FOR i: NAT IN [0..5] DO
pioState[i] _ TeleLoad.Read[h: lark.h, addr: pioItem.addr + i];
ENDLOOP;
out.PutRope["Relay Status: "];
out.PutRope[IF PIOOn[080H, iapioa] THEN "Reverted " ELSE "Not Reverted "];
out.PutRope[IF PIOOn[020H, ipioc] THEN "RevertHS " ELSE "Not RevertHS "];
out.PutRope[IF PIOOff[040H, iapioa] THEN "OffHook " ELSE "OnHook "];
out.PutRope[IF PIOOff[010H, ipioc] THEN "ARelay on " ELSE "ARelay off "];
out.PutRope["\nOutput devices: \n"];
out.PutRope[IF PIOOff[004H, iapioc] THEN "SideTone on " ELSE "SideTone off "];
out.PutRope[IF PIOOff[008H, iapioc] THEN "RingEnable on " ELSE "RingEnable off "];
out.PutRope[IF PIOOff[040H, ipioa] THEN "LED on " ELSE "LED off "];
[item: inAnItem, found: found] _ LarkPrograms.FindVariable[lark.program, "inAn"];
IF NOT found THEN RETURN["Can't find symbol inAn"];
inAn _ TeleLoad.ReadWord[h: lark.h, addr: inAnItem.addr];
out.PutRope["\nInput devices: "];
out.PutRope[IF LOOPHOLE[Basics.BITAND[inAn, AISwitch], CARDINAL] # 0 THEN "Switch on " ELSE "Switch off "];
out.PutRope[IF LOOPHOLE[Basics.BITAND[inAn, AIRing], CARDINAL] # 0 THEN "Ring on " ELSE "Ring off "];
out.PutRope[IF LOOPHOLE[Basics.BITAND[inAn, AIHookSwitch], CARDINAL] # 0 THEN "HookSwitch on " ELSE "HookSwitch off "];
out.PutChar['\n];
EXITS
BadComm => RETURN[BadCommRope];
};

DspQueue: LarkWork.LarkWorkProc = {
ENABLE {
Convert.Error => GOTO BadArgs;
TeleLoad.Failed => GOTO BadComm;
};
out: IO.STREAM _ lark.h.log;
queue: Queue;
queueAddress: TeleLoad.CoreAddress;
queueAddressSymbol: LarkPrograms.STObject;
found: BOOL;
maxLength: NAT;
TeleLoad.ResetCache[lark.h];
IF argv.argc < 2 THEN GOTO BadArgs;
[queueAddressSymbol, found] _ LarkPrograms.FindVariable[lark.program, argv[1]];
IF NOT found THEN RETURN["Queue name not found"];
queueAddress _ queueAddressSymbol.addr;
IF argv.argc > 2 THEN maxLength _ Basics.LowHalf[Convert.CardFromRope[argv[2]]] ELSE maxLength _ 20;
queue.head _ TeleLoad.ReadWord[lark.h, queueAddress];
queue.tail _ TeleLoad.ReadWord[lark.h, queueAddress + 2];
PrintQueue[lark: lark, out: out, q: queue, max: maxLength];
out.PutChar['\n];
EXITS
BadArgs => RETURN[BadArgsRope];
BadComm => RETURN[BadCommRope];
};

DspList: LarkWork.LarkWorkProc = {
ENABLE {
Convert.Error => GOTO BadArgs;
TeleLoad.Failed => GOTO BadComm;
};
out: IO.STREAM _ lark.h.log;
queue: Queue;
queueAddressSymbol: LarkPrograms.STObject;
maxLength: NAT;
found: BOOL;
TeleLoad.ResetCache[lark.h];
IF argv.argc < 2 THEN GOTO BadArgs;
[queueAddressSymbol, found] _ LarkPrograms.FindVariable[lark.program, argv[1]];
IF NOT found THEN RETURN["List name not found"];
queue.head _ queueAddressSymbol.addr;
queue.tail _ 0;
IF argv.argc > 2 THEN maxLength _ Basics.LowHalf[Convert.CardFromRope[argv[2]]] ELSE maxLength _ 20;
PrintQueue[lark: lark, out: out, q: queue, max: maxLength, printTail: FALSE];
out.PutChar['\n];
EXITS
BadArgs => RETURN[BadArgsRope];
BadComm => RETURN[BadCommRope];
};

LarkWork.RegisterLarkWorkProc[proc: DspVCB, key: ".DspVCB", caseMatters: FALSE, doc: "Print a voice command block", usage: ".DspVCB {vcb}"];
LarkWork.RegisterLarkWorkProc[proc: DspStatics, key: ".dstat", caseMatters: FALSE, doc: "Display statics listed in a file", usage: ".ds fileName"];
LarkWork.RegisterLarkWorkProc[proc: ZeroStatics, key: ".zstat", caseMatters: FALSE, doc: "Zero statics listed in a file", usage: ".zs fileName"];
LarkWork.RegisterLarkWorkProc[proc: DspAnalog, key: ".DspAnalog", caseMatters: FALSE, doc: "Display analog status", usage: ".DspAnalog"];
LarkWork.RegisterLarkWorkProc[proc: ESSet, key: ".ESSet", caseMatters: FALSE, doc: "Set Echo Suppression parameters", usage: ".ESSet VCB controlledVCB decayTime gt[0] gt[1] gt[2] gt[3] gt[4]"];
LarkWork.RegisterLarkWorkProc[proc: DspQueue, key: ".DspQueue", caseMatters: FALSE, doc: "Print a queue", usage: ".DspQueue queueAddress {max length (20)}"];
LarkWork.RegisterLarkWorkProc[proc: DspList, key: ".DspList", caseMatters: FALSE, doc: "Print a list", usage: ".DspList firstElement {max length (20)}"];
END.
May 3, 1983 6:21 pm, LCS, created
December 22, 1983 2:49 pm, LCS, Cedar 5

*LarkWorkCommandsC.mesa
L. Stewart, December 22, 1983 2:49 pm
Types
This command requires entries in a file of the form symbolName offset value even though the value field is ignored.

xbarState is indexed by column
First try to interpret the argument as a symbol
Register all the commands


�ʘJš
œ™Jš
œ%™%J˜š
Ïk	˜	Jšœ�œ�œ˜Jšœ�œ˜$Jš�œ
˜Jšœ�œ˜Jšœ
�œH˜ZJšœ	�œ&˜4Jšœ�œ�œ˜J˜Jšœ	�œa˜o—J˜Jšœ�œ
�˜ Jš�œ�œ$˜?Jš
�˜Jšœ�œ˜4Jšœ�œ˜+J™J˜Jšœ�œ�œ
˜"J˜š�œ�œ�œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœ�œ
˜Jšœ	�œÏc˜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šœ�œ
˜Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ
˜Jš
œ˜Jšœ
�œ
˜Jšœ
�œ
˜Jšœ
�œ
˜Jšœ
�œ
˜Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ
˜Jšœ
�œ
˜Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ�œ
�œ
˜$Jšœ
�˜J˜—J˜š
Ïnœ�œ#�œ
�œ�œ˜IJš	œC�œ�œ�œ�œ˜�
Jš	œC�œ�œ�œ�œ˜“
Jšœ�œC˜WJ˜—J˜šŸ	œ�œ#�œ
�œ˜PJš	œ�œ�œ�œ�œ˜aJ˜—J˜šŸ
œ�œ#�œ
�œ�œ
�œ�œ˜mJš
œ˜Jš
œ˜J˜š�œ�œ
�œ
�˜J˜
Jš�œ�œ
�œ
˜Jšœ�œ
˜Jš
œ!˜!Jš�œ�œ
�œ
˜J˜Jš
�˜Jš�œ˜Jš�œ
˜—J˜š�œ�œ˜Jš�œ�œ�œ�œ˜[J˜—J˜—J˜šŸœ�œ#�œ
�œ�œ�œ˜XJš	œ	�œ�œ�œ�œ˜_J˜J˜J˜1J˜J˜1Jš
œ˜J˜JšœC�œ�œ�œ˜Œ
J˜J˜Jš
œ5˜5Jš
œ˜J˜J˜Jš
œ4˜4Jš
œ˜J˜Jšœ�œ˜4J˜J˜J˜/Jš
œ˜J˜J˜J˜/Jš
œ˜J˜J˜J˜0Jš
œ˜J˜J˜J˜0Jš
œ˜J˜Jšœ<�œ�œ�œ˜{J˜Jš	œV�œ�œ�œ�œ˜»
J˜J˜J˜/Jš
œ˜J˜J˜J˜/Jš
œ˜J˜Jšœ+�œ�œ˜SJšœ?�œ�œ�œ˜Š
Jšœ-�œ�œ˜]J˜Jšœ/�œ�œ�œ˜€
Jšœ�œ�œ˜TJšœ �œ˜7J˜J˜—J˜šŸœ�œ5�œ�œ˜XJšœ�œ˜šŸœ�œ
�œ�œ˜$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š
œ˜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š
œ˜Jš
œ˜J˜—J˜š
œ!˜!š�œ˜Jšœ�œ	˜Jšœ�œ	˜ J˜—Jšœ�œ
�œ˜Jš
œ˜Jšœ
�œ
˜J˜Jšœ�œ
˜Jšœ�œ
˜	š�œ�œ˜Jš
œ9˜9Jš�œ�œ
�œ	˜"J˜—J˜OJš�œ�œ˜$Jš�œ
�œ˜&J˜Jš�œ�œ[�œ
�œ˜�
š�œ
�œ
�œ�˜Jšœ<�œ
�œ˜HJš�œ�œ>˜TJš�œ
˜—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˜OJš�œ�œ˜$Jš�œ
�œ˜&Jš
œ9˜9Jš�œ�œ
�œ	˜"Jš
œ<˜<Jš
�œ
�œ
�œ�œ
�œ	˜/Jš
œ:˜:Jš
�œ�œ
�œ	�œ
�œ	˜.š�œ�œ
�œ�˜Jš
œ?˜?Jš�œ
˜—J˜J˜!Jšœ �œ
�œ˜/Jš
œU˜UJš
œJ˜JJš
œQ˜Qš�œ�œ
�œ�˜Jš
œ^˜^Jš�œ
˜—J˜J˜!Jš
�˜Jšœ�œ˜Jšœ�œ˜J˜J˜—J™sJ™š
œ%˜%š�œ˜Jšœ�œ	˜Jšœ�œ	˜ J˜—Jšœ�œ
�œ˜Jšœ�œ
�œ˜#Jšœ�œ
�œ˜$J˜Jš�œ�œ
�œ	˜#Jš
œU˜UJš
�œ�œ
�œ
�œ
�œ˜š�œ�œ
�œž˜'Jšœ�œ˜Jš
œ˜Jš�œ
˜—š�œ�œ
�˜J˜JJšœ"�œ�œ�œ˜sJ˜
Jš�œ
˜—Jš
�˜Jšœ�œ˜Jšœ�œ˜J˜—J˜š
œ&˜&š�œ˜Jšœ�œ	˜Jšœ�œ	˜ J˜—Jšœ�œ
�œ˜Jšœ�œ
�œ˜#Jš�œ�œ
�œ	˜#Jš
œT˜TJš
�œ�œ
�œ
�œ
�œ˜J˜J˜!š�œ�œ
�˜J˜@Jš
œ˜J˜
Jš�œ
˜—J˜J˜!Jš
œ˜Jš
�˜Jšœ�œ˜Jšœ�œ˜J˜—J˜š
œ$˜$š�œ˜Jšœ�œ	˜ J˜—Jšœ�œ
�œ˜Jšœ�œ�œ
�œ
˜$Jšœ	�œ�œ
�œ!˜BJšœ	�œ�œ�œT˜vJšœ�œ�œ�œT˜tJ˜Jšœ
�œ�œ
�œ
˜#J˜J˜ Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ˜Jšœ�œ˜Jšœ�œ˜Jšœ�œ˜Jšœ�œ˜Jšœ�œ˜Jšœ
�œ˜Jšœ�œ˜Jšœ�œ˜š
Ÿœ�œ�œ�œ�œ˜/Jš�œ�œ�œ �œ˜MJ˜—š
Ÿœ�œ
�œ�œ�œ˜/Jš�œ�œ�œ�œ˜DJ˜—š
Ÿœ�œ
�œ�œ�œ˜0Jš�œ�œ�œ�œ˜DJ˜—J˜J˜TJš�œ
�œ�œ
�œ ˜8š�œ�œ
�œ�˜J˜?Jš�œ
˜—J™š�œ�œ
�œ�˜Jšœ�œ
˜š�œ�œ
�œ�˜Jš�œ�œ	�œ
˜&Jš�œ
˜—Jš�œ
�œ�œ
�œ
˜J˜š�œ�œ
�œ�˜Jš�œ�œ�œ˜BJš�œ
˜—J˜Jš�œ
˜—J˜PJš�œ
�œ�œ
�œ˜3š�œ�œ
�œ�˜J˜?Jš�œ
˜—Jš
œ˜Jšœ�œ�œ
�œ˜JJšœ�œ�œ
�œ˜IJšœ�œ�œ�œ˜DJšœ�œ�œ�œ˜IJš
œ$˜$Jšœ�œ�œ�œ˜NJšœ�œ�œ�œ˜RJšœ�œ�œ�œ
˜CJ˜QJš�œ
�œ�œ
�œ˜3J˜9Jš
œ!˜!Jš
œ�œ
�œ�œ�œ�œ�œ˜kJš
œ�œ
�œ�œ�œ�œ�œ˜eJš
œ�œ
�œ�œ�œ�œ�œ˜wJ˜Jš
�˜Jšœ�œ˜J˜—J˜š
œ#˜#š�œ˜Jšœ�œ	˜Jšœ�œ	˜ J˜—Jšœ�œ
�œ˜Jš
œ
˜
J˜#Jš
œ*˜*Jšœ�œ
˜Jšœ�œ
˜J˜Jš�œ�œ
�œ	˜#J™/J˜OJš�œ
�œ�œ
�œ˜1J˜'Jš�œ�œ;�œ˜dJš
œ5˜5Jš
œ9˜9Jš
œ;˜;J˜Jš
�˜Jšœ�œ˜Jšœ�œ˜J˜—J˜š
œ"˜"š�œ˜Jšœ�œ	˜Jšœ�œ	˜ J˜—Jšœ�œ
�œ˜Jš
œ
˜
Jš
œ*˜*Jšœ�œ
˜Jšœ�œ
˜J˜Jš�œ�œ
�œ	˜#J˜OJš�œ
�œ�œ
�œ˜0Jš
œ%˜%Jš
œ˜Jš�œ�œ;�œ˜dJšœF�œ˜MJ˜Jš
�˜Jšœ�œ˜Jšœ�œ˜J˜—J˜J™J™JšœI�œ>˜Œ
JšœL�œB˜“
JšœM�œ?˜‘
JšœO�œ5˜‰
JšœG�œu˜Á
JšœM�œK˜�
JšœK�œI˜™
J™Jš�œ
˜Jšœ�œ	˜!Jšœ�œ	˜'—…—A UÏ