DIRECTORY
Commander USING [CommandProc, Handle, Register],
IO,
Names USING [ MakeAtom ],
NamesGV USING [ AttributeSeq, AttributeSeqRec, GVGetAttributes, GVGetAttributeSeq, GVIsAuthenticated, GVSetAttribute, GVSetAttributeSeq, --GVUpdate, -- GVFlushCache, GVUpdateAll ],
Rope USING [ Cat, Equal, Length, ROPE, Substr ]
;
Action routines
We don't do updates automatically these days. To really affect Grapevine requires issuing the GVUpdate command (registered by NamesAndLog.bcd) manually. It will write all dirty entries, so use the flush operation judiciously.
UpdateAll:
PROC[] = {
Calling["UpdateAll"];
NamesGV.GVUpdateAll[];
};
FlushAll:
PROC[] = {
Calling["FlushAll"];
NamesGV.GVFlushCache[];
};
LarkDetails:
PROC[larkName:
ROPE] = {
Calling["DetailsOfLark#", larkName];
DoDetails[FullLark[larkName]];
};
Details:
PROC[rName:
ROPE] = {
Calling["Details", rName];
DoDetails[rName];
};
DoDetails:
PROC[rName:
ROPE] = {
SELECT NamesGV.GVIsAuthenticated[rName]
FROM
unknown, nonexistent => out.PutF["Couldn't find %s\n", rope[rName]];
ENDCASE => PrintDetails[rName];
};
Mode:
PROC[larkNum, newMode:
ROPE, update:
BOOL←
TRUE] = {
rName: ROPE𡤏ullLark[larkNum];
Calling["Mode", larkNum, newMode];
NamesGV.GVSetAttribute[rName, $mode, newMode];
IF update THEN NamesGV.GVUpdate[rName];
PrintDetails[rName];
};
Instance:
PROC[larkNum, newInstance:
ROPE, update:
BOOL←
TRUE] = {
aSeq: NamesGV.AttributeSeq;
rName: ROPE ← FullLark[larkNum];
Calling["Instance", larkNum, newInstance];
aSeq ← NamesGV.GVGetAttributeSeq[rName, $interface];
IF aSeq=NIL THEN aSeq ← NEW[NamesGV.AttributeSeqRec[4]];
aSeq.length𡤄
IF aSeq[0].attributeValue=NIL THEN aSeq[0] ← [,"LarkSmarts.Lark"];
aSeq[1] ← [,newInstance.Cat[".lark"]];
IF aSeq[2].attributeValue=NIL THEN aSeq[2] ← [,"1"];
IF aSeq[3].attributeValue=NIL THEN aSeq[3] ← [,"0"];
NamesGV.GVSetAttributeSeq[rName, $interface, aSeq];
IF update THEN NamesGV.GVUpdate[rName];
PrintDetails[rName];
};
SetAttribute:
PROC[rName, attributeName, attributeValue:
ROPE] = {
attribute: ATOM ← Names.MakeAtom[attributeName, FALSE];
NamesGV.GVSetAttribute[rName, attribute, attributeValue];
NamesGV.GVUpdate[rName];
PrintDetails[rName];
};
SetTune:
PROC[rName, tune:
ROPE] = {
len: INT ← tune.Length[];
larkRname: ROPE=rName.Cat[".lark"];
NamesGV.GVSetAttribute[larkRname, $tunea, tune.Substr[len: 50]];
NamesGV.GVSetAttribute[larkRname, $tuneb,
IF len>50 THEN tune.Substr[start: 50, len: 50] ELSE NIL];
NamesGV.GVSetAttribute[larkRname, $tunec,
IF len>100 THEN tune.Substr[start: 100, len: 50] ELSE NIL];
NamesGV.GVUpdate[larkRname];
PrintDetails[larkRname];
};
Make:
PROC[rName, extension, machine, instance, mode, net, host:
ROPE] = {
wsName: ROPE←IF net=NIL THEN NIL ELSE net.Cat["#",host,"#.Lark"];
fullUserName: ROPE←rName.Cat[".Lark"];
larkName: ROPE ← FullLark[machine];
Calling["Make", rName, extension, machine, instance, mode, net, host];
larkDetails] ← larkName, create];
rnameDetails] ← fullUserName, create];
wsDetails] ← wsName, create];
Instance[machine, instance.Cat[".Lark"], FALSE];
Mode[machine, mode, FALSE];
NamesGV.GVSetAttribute[larkName, $owner, fullUserName];
NamesGV.GVUpdate[larkName];
PrintDetails[larkName];
NamesGV.GVSetAttribute[fullUserName, $larkhost, Rope.Cat["173#", machine, "#"]];
NamesGV.GVSetAttribute[fullUserName, $extension, extension];
NamesGV.GVUpdate[fullUserName];
PrintDetails[fullUserName];
IF wsName=NIL THEN RETURN;
NamesGV.GVSetAttribute[wsName, $owner, rName];
NamesGV.GVUpdate[wsName];
PrintDetails[wsName];
};
Command Procs
SemiTok: IO.BreakProc = TRUSTED {RETURN[IF char='; THEN break ELSE other]; };
CommaTok: IO.BreakProc = TRUSTED {RETURN[IF char=', THEN break ELSE other]; };
DetailsCommand: Commander.CommandProc =
TRUSTED {
StartTok[cmd];
Details[Token[]]; };
UpdateAllCommand: Commander.CommandProc = TRUSTED { UpdateAll[]; };
FlushAllCommand: Commander.CommandProc =
TRUSTED { FlushAll[]; };
LarkCommand: Commander.CommandProc =
TRUSTED {
StartTok[cmd];
LarkDetails[Token[]]; };
MakeCommand: Commander.CommandProc =
TRUSTED {
rName, extension, machine, instance, mode, net, host: ROPE;
StartTok[cmd];
rName←Token[];
extension←Token[];
machine←Token[];
instance←Token[];
mode ← Token[];
net←Token[];
IF net.Equal["none"] THEN net←NIL ELSE host←Token[];
Make[rName, extension, machine, instance, mode, net, host]; };
InstanceCommand: Commander.CommandProc =
TRUSTED {
a1, a2: ROPE;
StartTok[cmd];
a1←Token[];
a2←Token[];
Instance[a1, a2]; };
ModeCommand: Commander.CommandProc =
TRUSTED {
a1, a2: ROPE;
StartTok[cmd];
a1←Token[];
a2←Token[];
Mode[a1, a2]; };
AttributeCommand: Commander.CommandProc =
TRUSTED {
a1, a2, a3: ROPE;
StartTok[cmd];
a1←Token[];
a2←Token[];
a3𡤌mdStream.GetLineRope[];
IF a3#NIL AND a3.Length[]#0 THEN a3�.Substr[start: 1] ELSE a3←NIL;
SetAttribute[a1, a2, a3]; };
TuneCommand: Commander.CommandProc =
TRUSTED {
a1, a2: ROPE;
StartTok[cmd];
a1←Token[];
a2𡤌mdStream.GetLineRope[];
IF a2#NIL AND a2.Length[]#0 THEN a2�.Substr[start: 1] ELSE a2←NIL;
SetTune[a1, a2];
};
DoTuneCommand: Commander.CommandProc =
TRUSTED {
a1, a2: ROPE;
StartTok[cmd];
a1←Token[];
a2←Token[];
SetAttribute[a1.Cat[".lark"], "dotune", a2]; };
Utilities
StartTok:
PROC[cmd: Commander.Handle] = {
cmdStream ← IO.RIS[cmd.commandLine];
out ← cmd.out;
};
Token: PROC RETURNS [r: ROPE ← NIL] = { r ← cmdStream.GetTokenRope[breakProc: IO.IDProc ! IO.EndOfStream => CONTINUE;].token; };
PrintDetails:
PROC[rName:
ROPE] = {
attributeSeq: NamesGV.AttributeSeq ← NamesGV.GVGetAttributes[rName];
authenticity:
ROPE ←
SELECT NamesGV.GVIsAuthenticated[rName]
FROM
$authentic => " (authentic)",
$bogus => " (bogus)",
$perhaps => "",
ENDCASE => " (??)";
out.PutF["rName: %s%s\n", rope[rName], rope[authenticity]];
IF attributeSeq#
NIL
THEN
FOR i:
INT
IN [0..attributeSeq.length)
DO
out.PutF[" %s: %s\n",
atom[attributeSeq[i].attributeName],
rope[attributeSeq[i].attributeValue] ];
ENDLOOP;
out.PutChar['\n];
};
FullLark:
PROC[larkName:
ROPE]
RETURNS [fullName:
ROPE] = {
RETURN[Rope.Cat["173#", larkName, "#.lark"]];
};
Calling:
PROC[funcName, a, b, c, d, e, f, g:
ROPE←
NIL] = {
res: ROPE𡤏uncName.Cat["[", a];
IF b#NIL THEN res←res.Cat[", ", b];
IF c#NIL THEN res←res.Cat[", ", c];
IF d#NIL THEN res←res.Cat[", ", d];
IF e#NIL THEN res←res.Cat[", ", e];
IF f#NIL THEN res←res.Cat[", ", f];
IF g#NIL THEN res←res.Cat[", ", g];
res←res.Cat["]\n "];
out.PutRope[res];
};
cmdStream: IO.STREAM;
Commander.Register["GVDetails", DetailsCommand, "Print RName details\nPrints attribute fields of fully-specified RName"];
Commander.Register["GVLark", LarkCommand, "Print details for Lark\nPrints attribute fields, given string for octal representation of a Lark's host ID; network 173B assumed."];
Commander.Register["GVMake", MakeCommand, "Update data base for Lark and user\nGVMake Swinehart.pa 4473 104 Morley O 3 333 sets Swinehart.pa.lark and 173#104#.lark and 3#333#.lark (creating if necessary) to contain all necessary attribute fields for Lark operation. Use none for 3 333 to avoid associating a workstation with the Lark."];
Commander.Register["GVInstance", InstanceCommand, "Set instance field\nGVInstance 100 Morley makes Morley.Lark the instance for the type LarkSmarts.Lark for Lark numbered 173#100#."];
Commander.Register["GVMode", ModeCommand, "Set Operational Mode\nGVMode 100 O sets the mode field of RName 173#100#.lark to O."];
Commander.Register["GVAttribute", AttributeCommand, "Set attribute field\nGVAttribute 173#104#.lark interface LarkSmarts.Lark, Strowger.Lark, 1, 0\n sets the interface attribute of the specified RName as specified."];
Commander.Register["GVUpdateAll", UpdateAllCommand, "Write all dirty cache entries\nWhen you issue a change request, it is stored in the cache but not written to GV until you issue this command."];
Commander.Register["GVFlushAll", FlushAllCommand, "Forget all cached Rnames. This will cancel any changes that have been made since the last GVFlushAll or GVUpdateAll."];
Commander.Register["GVTune", TuneCommand, "GVTune Swinehart.pa TuneString (rest of line!) sets the tune to be used if GVDoTune is set true."];
Commander.Register["GVDoTune", DoTuneCommand, "GVDoTune Swinehart.pa TRUE indicates that ring tune replaces standard ringing; false reverts."];