DIRECTORY
Commander USING [CommandProc, Handle, Register],
IO,
VoiceUtils USING [ MakeAtom, Rspec, RnameToRspec, RspecToRname ],
NamesGV USING [ AttributeSeq, AttributeSeqRec, GVGetAttributes, GVGetAttributeSeq, GVIsAuthenticated, GVSetAttribute, GVSetAttributeSeq, --GVUpdate, -- GVFlushCache, GVUpdateAll ],
Rope USING [ Cat, Equal, Length, ROPE, Substr ]
;

GVLarkImpl: CEDAR PROGRAM
IMPORTS
Commander,
IO,
VoiceUtils,
NamesGV,
Rope = {
OPEN IO;


ROPE: TYPE = Rope.ROPE;


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] = {
rName _ MakeRName[rName, rName];
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_FullLark[larkNum];
Calling["Mode", larkNum, newMode];
NamesGV.GVSetAttribute[rName, $mode, newMode];
PrintDetails[rName];
};

Owner: PROC[larkNum, newOwner: ROPE, update: BOOL_TRUE] = {
rName: ROPE_FullLark[larkNum];
newOwner _ MakeRName[newOwner, rNameDotLark];
Calling["Owner", larkNum, newOwner];
NamesGV.GVSetAttribute[rName, $owner, newOwner];
PrintDetails[rName];
};

Instance: PROC[larkNum, newInstance: ROPE, update: BOOL_TRUE] = {
aSeq: NamesGV.AttributeSeq;
rName: ROPE _ FullLark[larkNum];
newInstance _ MakeRName[newInstance, rName];
Calling["Instance", larkNum, newInstance];
aSeq _ NamesGV.GVGetAttributeSeq[rName, $interface];
IF aSeq=NIL THEN aSeq _ NEW[NamesGV.AttributeSeqRec[4]];
aSeq.length_4;
IF aSeq[0].attributeValue=NIL THEN aSeq[0] _ [,"LarkSmarts.Lark"];
aSeq[1] _ [,newInstance];
IF aSeq[2].attributeValue=NIL THEN aSeq[2] _ [,"1"];
IF aSeq[3].attributeValue=NIL THEN aSeq[3] _ [,"0"];
NamesGV.GVSetAttributeSeq[rName, $interface, aSeq];
PrintDetails[rName];
};

SetAttribute: PROC[rName, attributeName, attributeValue: ROPE] = {
attribute: ATOM _ VoiceUtils.MakeAtom[attributeName, FALSE];
rName _ MakeRName[rName, nameDotLark];
Calling["SetAttribute", rName, attributeName, attributeValue];
NamesGV.GVSetAttribute[rName, attribute, attributeValue];
PrintDetails[rName];
};

SetProgram: PROC[larkNum, program: ROPE, update: BOOL_TRUE] = {
rName: ROPE _ FullLark[larkNum];
Calling["SetProram", larkNum, program];
NamesGV.GVSetAttribute[rName, $program, program];
PrintDetails[rName];
};

SetTune: PROC[rName, doTune, tune: ROPE] = {
len: INT  _ tune.Length[]; 
rName _ MakeRName[rName, rNameDotLark];
Calling["Tune", rName, doTune, tune];
NamesGV.GVSetAttribute[rName, $dotune, doTune];
NamesGV.GVSetAttribute[rName, $ringtune, tune];
PrintDetails[rName];
};

Make: PROC[rName, extension, machine, instance, mode, net, host, program: ROPE] = {
wsName: ROPE_IF net=NIL THEN NIL ELSE net.Cat["#",host,"#"];
fullUserName: ROPE_MakeRName[rName, rNameDotLark];
larkName: ROPE _ FullLark[machine];
Calling["Make", rName, extension, machine, instance, mode, net, host];
Instance[machine, instance, FALSE];
Mode[machine, mode, FALSE];
NamesGV.GVSetAttribute[larkName, $owner, fullUserName];
IF program#NIL THEN NamesGV.GVSetAttribute[larkName, $program, program];
PrintDetails[larkName];
NamesGV.GVSetAttribute[fullUserName, $larkhost, Rope.Cat["173#", machine, "#"]];
NamesGV.GVSetAttribute[fullUserName, $extension, extension];
PrintDetails[fullUserName];
IF wsName=NIL THEN RETURN;
NamesGV.GVSetAttribute[wsName, $owner, rName];
NamesGV.GVSetAttribute[fullUserName, $workstationhost, wsName];
PrintDetails[wsName];
};


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, program: 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[];
program _ Token[];
Make[rName, extension, machine, instance, mode, net, host, program]; };

InstanceCommand: Commander.CommandProc = TRUSTED {
a1, a2: ROPE;
StartTok[cmd];
a1_Token[];
a2_Token[];
Instance[a1, a2];
};

DoProgramCommand: Commander.CommandProc = TRUSTED {
a1, a2: ROPE;
StartTok[cmd];
a1_Token[];
a2_Token[];
SetProgram[a1, a2];
};

ModeCommand: Commander.CommandProc = TRUSTED {
a1, a2: ROPE;
StartTok[cmd];
a1_Token[];
a2_Token[];
Mode[a1, a2]; };

OwnerCommand: Commander.CommandProc = TRUSTED {
a1, a2: ROPE;
StartTok[cmd];
a1_Token[];
a2_Token[];
Owner[a1, a2]; };

AttributeCommand: Commander.CommandProc = TRUSTED {
a1, a2, a3: ROPE;
StartTok[cmd];
a1_Token[];
a2_Token[];
a3_cmdStream.GetLineRope[];
IF a3#NIL AND a3.Length[]#0 THEN a3_a3.Substr[start: 1] ELSE a3_NIL;
SetAttribute[a1, a2, a3]; };

TuneCommand: Commander.CommandProc = TRUSTED {
a1, a2, a3: ROPE;
StartTok[cmd];
a1_Token[];
a2_Token[];
a3_cmdStream.GetLineRope[];
IF a3#NIL AND a3.Length[]#0 THEN a3_a3.Substr[start: 1] ELSE a3_NIL;
SetTune[a1, a2, a3];
};

DoTuneCommand: Commander.CommandProc = TRUSTED {
a1, a2: ROPE;
StartTok[cmd];
a1_Token[];
a2_Token[];
SetAttribute[a1.Cat[".lark"], "dotune", a2]; };


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_funcName.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];
};

RNameStyle: TYPE = { rName, nameDotLark, rNameDotLark };

MakeRName: PROC[name: ROPE, style: RNameStyle_ rNameDotLark]
RETURNS[rName: ROPE] = {
s1: VoiceUtils.Rspec = VoiceUtils.RnameToRspec[name, ".lark"];
s2: VoiceUtils.Rspec = VoiceUtils.RnameToRspec[s1.simpleName];
isDotLark: BOOL = s1.registry.Equal[".lark", FALSE];
RETURN[SELECT style FROM
rName => VoiceUtils.RspecToRname[s1],
nameDotLark => IF isDotLark THEN VoiceUtils.RspecToRname[s1]
ELSE VoiceUtils.RspecToRname[s1].Cat[".lark"],
rNameDotLark => IF s2#NIL THEN 
IF isDotLark THEN VoiceUtils.RspecToRname[s1] ELSE ERROR
ELSE VoiceUtils.RspecToRname[s1].Cat[".lark"],
ENDCASE=>NIL];
};


cmdStream: IO.STREAM;
out: 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["GVOwner", OwnerCommand, "Set Lark Owner\nGVOwner 100 fiddle.pa.lark sets the owner field of RName 173#100#.lark to fiddle.pa.lark."];
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 TRUE TuneString (rest of line!) sets the tune to be used, and does 'GVDoTune TRUE'."];
Commander.Register["GVDoTune", DoTuneCommand, "GVDoTune Swinehart.pa TRUE indicates that ring tune replaces standard ringing; false reverts."];
Commander.Register["GVProgram", DoProgramCommand, "Set program field\nGVProgram 100 LarkA makes LarkA.obj the program for Lark numbered 173#100#."];
}.

|GVLarkImpl.mesa
Last modified by D. Swinehart, January 4, 1986 5:24:40 pm PST
Last Edited by: Pier, May 10, 1984 1:08:21 pm PDT
Copies
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.
IF update THEN NamesGV.GVUpdate[rName];
IF update THEN NamesGV.GVUpdate[rName];
IF update THEN NamesGV.GVUpdate[rName];
NamesGV.GVUpdate[rName];
IF update THEN NamesGV.GVUpdate[rName];
NamesGV.GVUpdate[rName];
Command Procs
Utilities
Initialization
�Ê	·˜Jš
œ™Jš
œ=™=J™1J˜š
Ïk	˜	Jšœ
�œ!˜0Jš�œ
˜Jš
œA˜AJš
ϫ
˜´
Jšœ�œ�œ
˜/J˜
J˜—šœ�
˜š
�˜J˜
Jš�œ
˜J˜J˜Jš
œ˜Jš�œ
�œ
˜—J˜—š
œ™J˜Jš�œ�œ�œ
˜J˜—™J™J™ã
J˜šÏn	œ�œ˜Jš
œ˜J˜J˜J˜—šžœ�œ˜Jš
œ˜J˜J˜J˜—šžœ�œ�œ˜%Jš
œ$˜$J˜J˜J˜—šžœ�œ�œ˜J˜ Jš
œ˜Jš
œ˜J˜—J˜šž	œ�œ�œ˜ š�œ"�˜,J˜DJš�œ˜—J˜J˜—š
žœ�œ�œ
�œ
�œ˜9Jšœ�œ˜Jš
œ"˜"Jš
œ.˜.Jš�œ�œ™'Jš
œ˜J˜J˜—š
žœ�œ�œ
�œ
�œ˜;Jšœ�œ˜J˜-Jš
œ$˜$Jš
œ0˜0Jš�œ�œ™'Jš
œ˜J˜—J˜š
žœ�œ�œ
�œ
�œ˜AJ˜Jšœ�œ˜ J˜,Jš
œ*˜*Jš
œ4˜4Jš�œ�œ
�œ�œ˜8J˜Jš�œ�œ
�œ ˜BJš
œ˜Jš�œ�œ
�œ˜4Jš�œ�œ
�œ˜4Jš
œ3˜3Jš�œ�œ™'Jš
œ˜Jš
œ˜—J˜šžœ�œ'�œ˜BJšœ�œ&�œ˜<J˜&Jš
œ>˜>Jš
œ9˜9Jš
œ™Jš
œ˜Jš
œ˜—J˜š
ž
œ�œ�œ
�œ
�œ˜?Jšœ�œ˜ Jš
œ'˜'Jš
œ1˜1Jš�œ�œ™'Jš
œ˜Jš
œ˜—J˜šžœ�œ�œ˜,Jšœ�œ˜Jš
œ'˜'Jš
œ%˜%Jš
œ/˜/Jš
œ/˜/Jš
œ™Jš
œ˜Jš
œ˜—J˜šžœ�œ@�œ˜SJš
œ�œ
�œ�œ
�œ
�œ
�œ˜<Jšœ�œ ˜2Jšœ
�œ˜#Jš
œF˜FJšœ�œ˜#Jšœ�œ˜J˜7Jš�œ	�œ
�œ5˜HJš
œ˜Jš
œP˜PJš
œ<˜<Jš
œ˜Jš�œ�œ
�œ
�œ
˜Jš
œ.˜.Jš
œ?˜?Jš
œ˜J˜J˜——™
J˜Jš
œ	�œ
�œ�œ
�œ	�œ�œ˜MJš
œ
�œ
�œ�œ
�œ	�œ�œ˜NJ˜šœ(�œ˜1J˜J˜J˜—Jšœ*�œ˜CJ˜šœ)�œ˜AJ˜—šœ%�œ˜.J˜J˜—J˜šœ%�œ˜.Jšœ?�œ
˜DJ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜J˜J˜Jš�œ�œ�œ
�œ˜4J˜Jš
œG˜G—J˜šœ)�œ˜2Jšœ�œ
˜
J˜Jš
œ˜Jš
œ˜J˜J˜—J˜šœ*�œ˜3Jšœ�œ
˜
J˜Jš
œ˜Jš
œ˜J˜J˜J˜—šœ%�œ˜.Jšœ�œ
˜
J˜Jš
œ˜Jš
œ˜J˜—J˜šœ&�œ˜/Jšœ�œ
˜
J˜Jš
œ˜Jš
œ˜J˜J˜—šœ*�œ˜3Jšœ�œ
˜J˜Jš
œ˜Jš
œ˜J˜Jš�œ�œ
�œ�œ�œ�˜DJ˜—J˜šœ%�œ˜.Jšœ�œ
˜J˜Jš
œ˜Jš
œ˜J˜Jš�œ�œ
�œ�œ�œ�˜DJ˜J˜—J˜šœ'�œ˜0Jšœ�œ
˜
J˜Jš
œ˜Jš
œ˜J˜/—J˜—™	J˜šžœ�œ˜)Jšœ�œ
�œ˜$J˜J˜J˜—Jšžœ�œ
�œ�œ�œ,�œ
�œ�œ˜€
J˜šžœ�œ�œ˜#J˜Dšœ�œ�œ"�˜AJ˜J˜J˜Jš�œ˜—J˜;š
�œ�œ
�œ
�œ�œ
�œ�˜B˜J˜$J˜'—Jš�œ
˜—J˜J˜—J˜š
žœ�œ�œ�œ�œ˜;Jš�œ'˜-Jš
œ˜J˜—šžœ�œ �œ
�œ˜:Jšœ�œ˜Jš�œ�œ
�œ˜#Jš�œ�œ
�œ˜#Jš�œ�œ
�œ˜#Jš�œ�œ
�œ˜#Jš�œ�œ
�œ˜#Jš�œ�œ
�œ˜#J˜J˜J˜J˜—Jšœ�œ(˜8J˜šž	œ�œ�œ"˜<Jš�œ�œ˜J˜>Jš
œ>˜>Jšœ�œ�œ˜4š�œ
�œ�˜J˜%˜<Jš�œ*˜.—šœ�œ�œ
�œ
˜Jš�œ�œ�œ
�˜8Jš�œ*˜.—Jš�œ�œ˜—J˜J˜——J™˜Jšœ�œ
�œ
˜šœ�œ
�œ
˜J˜—Jš
œy˜yJš
œ¯
˜¯
Jš
œÒ˜ÒJš
œ·
˜·
Jš
œ�
˜�
Jš
Ϫ
˜™
J˜Ù
J˜Å
J˜«
J˜•
J˜�
Jš
œ”
˜”
—J˜J˜—…—%ú2-